def handle(self, app, serve, no_index): app.jinja_loader # ugly workaround app.blohg.init_repo(REVISION_DEFAULT) app.url_map = self.remap_rules(app.url_map, no_index) # That's a risky one, it woud be better to give a parameter to the # freezer app.root_path = app.config.get('REPO_PATH') freezer = Freezer(app) def static_generator(static_dir): for f in app.blohg.changectx.files: if f.startswith(static_dir): yield dict(filename=f[len(static_dir):] \ .strip(posixpath.sep)) @freezer.register_generator def static(): """Walk the static dir and freeze everything""" return static_generator('static') @freezer.register_generator def attachments(): """Walk the attachment dir and freeze everything""" return static_generator(app.config['ATTACHMENT_DIR']) freezer.freeze() if serve: freezer.serve()
def freeze(destination): '''Freeze the wiki to the destination directory.''' # If the freezer is provided a relative URL then it behaves by trying to # write to package area. This won't work if the package is installed so # convert the relative path to an absolute one. if not os.path.isabs(destination): destination = os.path.join(os.getcwd(), destination) # Set MarkWiki in a freezing mode so that certain elements of the views # won't get rendered. app.config['FREEZING'] = True app.config['FREEZER_IGNORE_MIMETYPE_WARNINGS'] = True app.config['FREEZER_DESTINATION'] = destination # The freeze operation is destructive because it follows the delete # links. Copy the wiki into a temporary area and work with that instead. _create_wiki_copy() freezer = Freezer(app) # Add the URL generator to suppress a warning. It won't really do anything. @freezer.register_generator def delete(): yield {'page_path': 'Home'} try: freezer.freeze() except OSError: return ('Failed to freeze the MarkWiki. Do you have permission to ' 'write to the destination directory?') return _prune_frozen(destination)
def main(): server.app.config['FREEZER_DESTINATION'] = config.OPTIONS['destination'] server.app.config['FREEZER_BASE_URL'] = config.OPTIONS['baseurl'] freezer = Freezer(server.app) freezer.freeze() return freezer
def freeze_topic_model_browser(): global token topic_model_browser_app.config.update( FREEZER_BASE_URL='http://mediamining.univ-lyon2.fr/people/guille/cats/tom/' + token, FREEZER_DESTINATION='tom/' + token, FREEZER_IGNORE_404_NOT_FOUND=True, FREEZER_REMOVE_EXTRA_FILES=False, FREEZER_DESTINATION_IGNORE=['.tsv', '.json'] ) topic_model_browser_app.debug = False topic_model_browser_app.testing = True topic_model_browser_app.config['ASSETS_DEBUG'] = False print('Freeze topic model browser') topic_model_freezer = Freezer(topic_model_browser_app) print('Finalizing the topic model browser...') @topic_model_freezer.register_generator def topic_details(): for _topic_id in range(topic_model.nb_topics): yield {'tid': _topic_id} @topic_model_freezer.register_generator def document_details(): for _doc_id in range(topic_model.corpus.size): yield {'did': _doc_id} @topic_model_freezer.register_generator def word_details(): for _word_id in range(len(topic_model.corpus.vocabulary)): yield {'wid': _word_id} topic_model_freezer.freeze() print('Done.')
def take_action(self, args): self.app.ara.config['FREEZER_DESTINATION'] = os.path.abspath(args.path) if args.playbook is not None: self.app.ara.config['ARA_PLAYBOOK_OVERRIDE'] = args.playbook self.log.warning('Generating static files at %s...', args.path) filterwarnings('ignore', '.*', NotFoundWarning) if self.app.ara.config['ARA_IGNORE_EMPTY_GENERATION']: filterwarnings('ignore', '.*', MissingURLGeneratorWarning) freezer = Freezer(self.app.ara) # Patternfly fonts are called from inside the CSS and are therefore # not automatically found by flask-frozen. We need to generate URLs # for the fonts. patternfly = self.app.ara.config['XSTATIC']['patternfly'] @freezer.register_generator def serve_static_packaged(): for font in walk_directory(os.path.join(patternfly, 'fonts')): yield dict( module='patternfly', filename='fonts/%s' % font ) freezer.freeze() print('Done.')
def freeze(): """Prepare and run the freezer""" app = app_factory({'FREEZER_DESTINATION': join('..', 'output')}) app.context_processor(freezer_template_context) freezer = Freezer(app, with_static_files=False) freezer.register_generator(partial(bootstrap_fonts, app)) freezer.freeze() copy_extra(freezer)
def freeze(): """ Freeze the site into static files. This function has severe problem. Do not use! """ from flask_frozen import Freezer freezer = Freezer(app) freezer.freeze()
def build_html(): from flask_frozen import Freezer from app import views views.app.config['FREEZER_DESTINATION'] = '../build' views.app.testing = True freezer = Freezer(views.app, with_static_files=False) freezer.register_generator(views.school_url_generator) freezer.register_generator(views.blog_url_generator) freezer.freeze()
def freeze(): """首页静态化""" from xueer.hello import hello from flask_frozen import Freezer freezer = Freezer(hello) if __name__ == '__main__': freezer.freeze()
def freeze(*args): import shutil from flask import url_for freezer = Freezer(app) freezer.freeze() # Copy the boilerplate files (favicon, robots.txt) to the freezer for filename in app.config.get('BOILER_FILES'): shutil.copy(app.config.get('BOILER_FULL_URL') + filename, app.config.get('FREEZER_DESTINATION'))
def freeze_app(): from flask_frozen import Freezer debugged = app.debug app.debug = True url_rules = ('about', 'schedule', 'logistics', 'partner', 'register', 'thanks', 'downloads', 'live') for rule in url_rules: app.add_url_rule('/<lang>/{}/'.format(rule), rule, partial(page, page=rule)) freezer = Freezer(app) freezer.freeze() app.debug = debugged
def build_html(): from flask_frozen import Freezer from app import views views.app.config["FREEZER_DESTINATION"] = "../build" views.app.config["FREEZER_REMOVE_EXTRA_FILES"] = False views.app.testing = True freezer = Freezer(views.app, with_static_files=False) freezer.register_generator(views.school_url_generator) freezer.register_generator(views.blog_url_generator) freezer.freeze()
def test_transitivity(self): with self.built_app() as (temp, app, freezer, urls): with temp_directory() as temp2: # Run the freezer on it's own output app2 = freezer.make_static_app() app2.config["FREEZER_DESTINATION"] = temp2 app2.debug = True freezer2 = Freezer(app2) freezer2.register_generator(self.filenames.iterkeys) freezer2.freeze() destination = app.config["FREEZER_DESTINATION"] self.assertEquals(read_all(destination), read_all(temp2))
def process_build(args): """Process the build""" if args.dir: if os.path.isdir(args.dir): target = args.dir else: target = os.path.join(APP_BASE_PATH, args.dir) app.config['FREEZER_DESTINATION'] = target if args.base: app.config['FREEZER_BASE_URL'] = args.base freezer = Freezer(app) freezer.freeze()
def build(): """Build blog""" app.config["BLOG"]["posts"] = sorted(load(["posts"]), key=lambda post: post.revdate, reverse=True) app.config["FREEZER_BASE_URL"] = app.config["BLOG"]["base_url"] app.config["FREEZER_DESTINATION"] = "../build" app.static_url_path = app.config["BLOG"]["base_path"] + "static/" freezer = Freezer(app) freezer.freeze()
def build_individual_repositories(repository_list): app.config['FREEZER_DESTINATION'] = os.path.abspath("static") app.config['FREEZER_BASE_URL'] = "https://dabo.guru/" app.config['FREEZER_REMOVE_EXTRA_FILES'] = False freezer = Freezer(app=app, with_static_files=False, with_no_argument_rules=False, log_url_for=True) for repository in repository_list: def url_generator(): return documentation.get_possible_pages_for_frozen_flask(repository) freezer.register_generator(url_generator) with warnings.catch_warnings(): warnings.filterwarnings("ignore", category=MissingURLGeneratorWarning) freezer.freeze()
def freeze(): freezer = Freezer(app) @freezer.register_generator def page_list(): for lang_code in ['en', 'fr']: yield 'pages.index', {'lang_code': lang_code} yield 'pages.guide', {'lang_code': lang_code} yield 'schedule.index', {'lang_code': lang_code} yield '/{}/schedule/schedule.json'.format(lang_code) yield '/{}/schedule/schedule.ics'.format(lang_code) freezer.freeze()
def run(self): app = self.app app.init() freezer = Freezer(app) logging.getLogger().setLevel(logging.INFO) logging.info('Generating static pages...') @freezer.register_generator def generate_pages(): for p in app.pages: if p.path == 'index': yield '/' # logging.info('Generating %s' % p.url) yield p.url @freezer.register_generator def generate_datafiles(): yield '/api/pages/all.json' yield '/api/posts.json' for p in app.pages: yield '/api/pages/%s.json' % p.path @freezer.register_generator def generate_attachments(): for p in app.pages: res_path = path.join(path.dirname(p._filename), p.name) if path.exists(res_path): for root, dirs, files in walk(res_path): for f in files: if not f.endswith('.md'): f_p = path.join(path.dirname(p._filename), p.name, f) if path.exists(f_p): yield p.url + '/' + f @freezer.register_generator def generate_archives(): for archive in app.site.archives: yield '/archives/%s' % archive.title freezer.freeze() logging.info('Generation completed.Doing cleanup....') for root, dirs, files in walk(path.join(getcwd(), 'builds')): for d in dirs: if path.basename(d) in ['.webassets-cache', '_styles', '_scripts']: rmtree(path.join(root, d)) for f in files: if path.splitext(f)[1] in ['.less', '.scss', '.coffee']: remove(path.join(root, f))
def generate(): app.config['FREEZER_DESTINATION'] = settings.web_app_location app.config['FREEZER_BASE_URL'] = settings.external_url freezer = Freezer(app) copy = copytext.Copy(settings.copy_sheet_location) @freezer.register_generator def candidate_page(): for sheetName in copy.sheetNames(): if sheetName == 'metadata' or sheetName == 'Attribution': continue for row in copy[sheetName]: yield {"candidate_id": row['Candidate Name'].unescape().replace(" ", "_").replace("/", "_")} freezer.freeze()
def freeze_event_browser(): global topic_associations, author_list, token os.makedirs('mabed/'+token+'/static/data') print('Freeze event browser') event_browser_app.config.update( FREEZER_BASE_URL='http://mediamining.univ-lyon2.fr/people/guille/cats/mabed/'+token, FREEZER_DESTINATION='mabed/'+token, FREEZER_IGNORE_404_NOT_FOUND=True, FREEZER_REMOVE_EXTRA_FILES=False, ) event_browser_freezer = Freezer(event_browser_app) event_browser_app.debug = False event_browser_app.testing = True event_browser_app.config['ASSETS_DEBUG'] = False event_browser_freezer.freeze() print('Done.')
def build_pages(): ignored = [bundle.output for bundle in assets] + ["rust"] app.config['FREEZER_DESTINATION'] = os.path.abspath("static") app.config['FREEZER_BASE_URL'] = "https://dabo.guru/" app.config['FREEZER_DESTINATION_IGNORE'] = ignored app.config['FREEZER_IGNORE_ENDPOINTS'] = ['oauth_respond', 'mc_api_name', 'mc_api_uuid', 'serve_markdown', 'uuid_api'] freezer = Freezer(app=app, with_static_files=False, with_no_argument_rules=False, log_url_for=True) freezer.register_generator(no_argument_rules_urls_with_ignore) freezer.register_generator(markdown_url_generator) freezer.register_generator(lambda: completely_static_files) print("Updating documentation") documentation.update_all_repositories(config) print("Freezing") with warnings.catch_warnings(): warnings.filterwarnings("ignore", category=MissingURLGeneratorWarning) freezer.freeze()
def _generate(app, destination): app.config.update( FREEZER_RELATIVE_URLS=True , FREEZER_DESTINATION=destination ) freezer_config = app.config['generator_config'].get('freezer_config', None) if freezer_config: app.config.update(freezer_config) freezer = Freezer( app # We'll have to request all pages manually. This # way we can create some endpoints pro forma # without yielding 404 errors. , with_no_argument_rules=False) freezer.register_generator(app.config['menu'].allLinks) freezer.freeze()
def build(config_overrides): app = create_app(config_overrides) app.config['FREEZER_REMOVE_EXTRA_FILES'] = True freezer = Freezer(app) @freezer.register_generator def page_url_generator(): cms = get_or_create_cms() contents = cms.structure() folder_names = contents['folders'].keys() for folder in folder_names: yield 'page_router.folder_index', {'folder_name': folder} page_names = contents['folders'][folder]['pages'].keys() for page in page_names: yield 'page_router.render_page', {'folder_name': folder, 'page_name': page} freezer.freeze()
def freeze_the_app(): app.config['JSMAIN'] = 'main-built' freezer = Freezer(app) subprocess.call(['compass compile -e production --force'], shell=True) subprocess.call(['r.js -o build.js'], shell=True) freezer.freeze()
def build(): freezer = Freezer(app) freezer.freeze()
def build(self, output_path=os.path.join(os.getcwd(), "build")): self.app.config["FREEZER_DESTINATION"] = output_path freezer = Freezer(self.app) freezer.freeze()
def export_static(): freezer = Freezer(app) freezer.freeze()
""" @cube.register_generator def page(): for page in pages: yield {'path': page['permalink']} """ Check to ensure that the application is loaded through a virtual enviornment. If it is not, prompt the user to either install a virtual enviornment or activate the one with the applciation. """ if __name__ == "__main__": if "VIRTUAL_ENV" not in os.environ: print(""" Your Virtual Environment or virtualenv has not been activated. To use this application, please activate it by executing: source venv/bin/activate If the problem persists, ensure that virtualenv is installed: pip install virtualenv and that all other requirements have been satisfied. """) elif len(sys.argv) > 1 and sys.argv[1] == "build": cube.freeze() else: commonscloudstatic.run(port=commonscloudstatic.config['PORT'])
def main(): app.config['FREEZER_DESTINATION'] = '../build' freezer = Freezer(app) freezer.freeze() with open(Path(freezer.root) / 'CNAME', 'w') as f: f.write('transparenz.flipdot.org')
def create_jamstack(): app.config["FREEZER_IGNORE_MIMETYPE_WARNINGS"] = True app.config["FREEZER_DESTINATION"] = get_path("output") / "static_html" freezer = Freezer(app) freezer.freeze()
@app.route("/resume/") def resume(): return render_template('resume.html') @app.route("/projects/") def projects(): return render_template('projects.html') # Removing Resume Download for static version # @app.route("/show/") # def show_static_pdf(): # file_url = os.path.join(current_app.root_path, 'static/DavidKucherResume.pdf') # return send_file(file_url, mimetype='pdf', # download_name='DavidKucherResume.pdf', # as_attachment=True) freezer = Freezer(app) if __name__ == '__main__': if len(sys.argv) > 1: if sys.argv[1] == 'freeze': res = freezer.freeze() elif sys.argv[1] == 'serve': res = freezer.run() else: app.run(port=8888)
with 'index.html' at the end. :param page_path: str :return: str """ if not page_path.endswith('/'): page_path += '/' return process_page(page_path + 'index') @app.after_request def add_header(request): request.headers["Cache-Control"] = "no-cache, no-store, must-revalidate" request.headers["Pragma"] = "no-cache" request.headers["Expires"] = "0" request.headers['Cache-Control'] = 'public, max-age=0' return request if __name__ == '__main__': if len(sys.argv) > 1 and sys.argv[1] == "build": build_mode = True urls = freezer.freeze() generate_sitemap(urls) if len(build_errors) > 0: for error in build_errors: sys.stderr.write(error + '\n') sys.exit(-1) else: app.run(host="0.0.0.0", debug=True, threaded=True)
class TarbellSite: def __init__(self, path, client_secrets_path=None, quiet=False): self.app = Flask(__name__) self.quiet = quiet self.app.jinja_env.finalize = silent_none # Don't print "None" self.app.debug = True # Always debug self.path = path self.project, self.base = self.load_project(path) self.data = {} self.hooks = self.process_hooks(hooks) self.expires = 0 # add routes self.app.add_url_rule('/', view_func=self.preview) self.app.add_url_rule('/<path:path>', view_func=self.preview) self.app.add_url_rule('/data.json', view_func=self.data_json) self.app.register_blueprint(filters) self.app.before_request(self.add_site_to_context) self.app.after_request(self.never_cache_preview) # centralized freezer setup self.app.config.setdefault('FREEZER_RELATIVE_URLS', True) self.app.config.setdefault('FREEZER_REMOVE_EXTRA_FILES', False) self.app.config.setdefault('FREEZER_DESTINATION', os.path.join(os.path.realpath(self.path), '_site')) self.freezer = Freezer(self.app) self.freezer.register_generator(self.find_files) def add_site_to_context(self): """ Add current Tarbell object to Flask's `g` """ g.current_site = self def never_cache_preview(self, response): """ Ensure preview is never cached """ response.cache_control.max_age = 0 response.cache_control.no_cache = True response.cache_control.must_revalidate = True response.cache_control.no_store = True return response def process_hooks(self, hooks): """ Process all project hooks """ try: enabled_hooks = self.project.HOOKS except AttributeError: return hooks def call_hook(self, hook, *args, **kwargs): """ Calls each registered hook """ for function in self.hooks[hook]: function.__call__(*args, **kwargs) def _get_base(self, path): """ Get project blueprint """ base = None # Slightly ugly DRY violation for backwards compatibility with old # "_base" convention if os.path.isdir(os.path.join(path, "_blueprint")): base_dir = os.path.join(path, "_blueprint/") # Get the blueprint template and register it as a blueprint if os.path.exists(os.path.join(base_dir, "blueprint.py")): filename, pathname, description = imp.find_module('blueprint', [base_dir]) base = imp.load_module('blueprint', filename, pathname, description) self.blueprint_name = "_blueprint" else: puts("No _blueprint/blueprint.py file found") elif os.path.isdir(os.path.join(path, "_base")): puts("Using old '_base' convention") base_dir = os.path.join(path, "_base/") if os.path.exists(os.path.join(base_dir, "base.py")): filename, pathname, description = imp.find_module('base', [base_dir]) base = imp.load_module('base', filename, pathname, description) self.blueprint_name = "_base" else: puts("No _base/base.py file found") if base: base.base_dir = base_dir if hasattr(base, 'blueprint') and isinstance(base.blueprint, Blueprint): self.app.register_blueprint(base.blueprint, site=self) return base def load_project(self, path): """ Load a Tarbell project """ base = self._get_base(path) filename, pathname, description = imp.find_module('tarbell_config', [path]) project = imp.load_module('project', filename, pathname, description) try: self.key = project.SPREADSHEET_KEY self.client = get_drive_api() except AttributeError: self.key = None self.client = None try: project.CREATE_JSON except AttributeError: project.CREATE_JSON = False try: project.S3_BUCKETS except AttributeError: project.S3_BUCKETS = {} project.EXCLUDES = list(set(EXCLUDES + getattr(project, 'EXCLUDES', []) + getattr(base, 'EXCLUDES', []))) # merge project template types with defaults project.TEMPLATE_TYPES = set(getattr(project, 'TEMPLATE_TYPES', [])) | set(TEMPLATE_TYPES) try: project.DEFAULT_CONTEXT except AttributeError: project.DEFAULT_CONTEXT = {} project.DEFAULT_CONTEXT.update({ "PROJECT_PATH": self.path, "ROOT_URL": "127.0.0.1:5000", "SPREADSHEET_KEY": self.key, "BUCKETS": project.S3_BUCKETS, "SITE": self, }) # Set up template loaders template_dirs = [path] if base: template_dirs.append(base.base_dir) error_path = os.path.join(os.path.dirname(os.path.abspath(__file__)), 'error_templates') template_dirs.append(error_path) self.app.jinja_loader = TarbellFileSystemLoader(template_dirs) # load the project blueprint, if it exists if hasattr(project, 'blueprint') and isinstance(project.blueprint, Blueprint): self.app.register_blueprint(project.blueprint, site=self) return project, base def _resolve_path(self, path): """ Resolve static file paths """ filepath = None mimetype = None for root, dirs, files in self.filter_files(self.path): # Does it exist in error path? error_path = os.path.join(os.path.dirname(os.path.abspath(__file__)), 'error_templates', path) try: with open(error_path): mimetype, encoding = mimetypes.guess_type(error_path) filepath = error_path except IOError: pass # Does it exist in Tarbell blueprint? if self.base: basepath = os.path.join(root, self.blueprint_name, path) try: with open(basepath): mimetype, encoding = mimetypes.guess_type(basepath) filepath = basepath except IOError: pass # Does it exist under regular path? fullpath = os.path.join(root, path) try: with open(fullpath): mimetype, encoding = mimetypes.guess_type(fullpath) filepath = fullpath except IOError: pass return filepath, mimetype def data_json(self, extra_context=None, publish=False): """ Serve site context as JSON. Useful for debugging. """ if not self.project.CREATE_JSON: # nothing to see here, but the right mimetype return jsonify() if not self.data: # this sets site.data by spreadsheet or gdoc self.get_context(publish) return jsonify(self.data) def preview(self, path=None, extra_context=None, publish=False): """ Serve up a project path """ try: self.call_hook("preview", self) if path is None: path = 'index.html' # Detect files filepath, mimetype = self._resolve_path(path) # Serve dynamic if filepath and mimetype and mimetype in self.project.TEMPLATE_TYPES: context = self.get_context(publish) context.update({ "PATH": path, "PREVIEW_SERVER": not publish, "TIMESTAMP": int(time.time()), }) if extra_context: context.update(extra_context) rendered = render_template(path, **context) return Response(rendered, mimetype=mimetype) # Serve static if filepath: dir, filename = os.path.split(filepath) return send_from_directory(dir, filename) except Exception as e: ex_type, ex, tb = sys.exc_info() try: # Find template with name of error cls = e.__class__ ex_type, ex, tb = sys.exc_info() context = self.project.DEFAULT_CONTEXT context.update({ 'PATH': path, 'traceback': traceback.format_exception(ex_type, ex, tb), 'e': e, }) if extra_context: context.update(extra_context) try: error_path = '_{0}.{1}.html'.format(cls.__module__, cls.__name__) rendered = render_template(error_path, **context) except TemplateNotFound: # Find template without underscore prefix, @TODO remove in v1.1 error_path = '{0}.{1}.html'.format(cls.__module__, cls.__name__) rendered = render_template(error_path, **context) return Response(rendered, mimetype="text/html") except TemplateNotFound: # Otherwise raise old error reraise(ex_type, ex, tb) # Last ditch effort -- see if path has "index.html" underneath it if not path.endswith("index.html"): if not path.endswith("/"): path = "{0}/".format(path) path = "{0}{1}".format(path, "index.html") return self.preview(path) # It's a 404 if path.endswith('/index.html'): path = path[:-11] rendered = render_template("404.html", PATH=path) return Response(rendered, status=404) def get_context(self, publish=False): """ Use optional CONTEXT_SOURCE_FILE setting to determine data source. Return the parsed data. Can be an http|https url or local file. Supports csv and excel files. """ context = self.project.DEFAULT_CONTEXT try: file = self.project.CONTEXT_SOURCE_FILE # CSV if re.search(r'(csv|CSV)$', file): context.update(self.get_context_from_csv()) # Excel if re.search(r'(xlsx|XLSX|xls|XLS)$', file): context.update(self.get_context_from_xlsx()) except AttributeError: context.update(self.get_context_from_gdoc()) return context def get_context_from_xlsx(self): """ Get context from an Excel file """ if re.search('^(http|https)://', self.project.CONTEXT_SOURCE_FILE): resp = requests.get(self.project.CONTEXT_SOURCE_FILE) content = resp.content else: try: with open(self.project.CONTEXT_SOURCE_FILE) as xlsxfile: content = xlsxfile.read() except IOError: filepath = "%s/%s" % ( os.path.abspath(self.path), self.project.CONTEXT_SOURCE_FILE) with open(filepath) as xlsxfile: content = xlsxfile.read() data = process_xlsx(content) if 'values' in data: data = copy_global_values(data) return data def get_context_from_csv(self): """ Open CONTEXT_SOURCE_FILE, parse and return a context """ if re.search('^(http|https)://', self.project.CONTEXT_SOURCE_FILE): data = requests.get(self.project.CONTEXT_SOURCE_FILE) reader = csv.reader( data.iter_lines(), delimiter=',', quotechar='"') ret = {rows[0]: rows[1] for rows in reader} else: try: with open(self.project.CONTEXT_SOURCE_FILE) as csvfile: reader = csv.reader(csvfile, delimiter=',', quotechar='"') ret = {rows[0]: rows[1] for rows in reader} except IOError: file = "%s/%s" % ( os.path.abspath(self.path), self.project.CONTEXT_SOURCE_FILE) with open(file) as csvfile: reader = csv.reader(csvfile, delimiter=',', quotechar='"') ret = {rows[0]: rows[1] for rows in reader} ret.update({ "CONTEXT_SOURCE_FILE": self.project.CONTEXT_SOURCE_FILE, }) return ret def get_context_from_gdoc(self): """ Wrap getting context from Google sheets in a simple caching mechanism. """ try: start = int(time.time()) if not self.data or start > self.expires: self.data = self._get_context_from_gdoc(self.project.SPREADSHEET_KEY) end = int(time.time()) ttl = getattr(self.project, 'SPREADSHEET_CACHE_TTL', SPREADSHEET_CACHE_TTL) self.expires = end + ttl return self.data except AttributeError: return {} def _get_context_from_gdoc(self, key): """ Create a Jinja2 context from a Google spreadsheet. """ try: content = self.export_xlsx(key) data = process_xlsx(content) if 'values' in data: data = copy_global_values(data) return data except BadStatusLine: # Stale connection, reset API and data puts("Connection reset, reloading drive API") self.client = get_drive_api() return self._get_context_from_gdoc(key) def export_xlsx(self, key): """ Download xlsx version of spreadsheet. """ spreadsheet_file = self.client.files().get(fileId=key).execute() links = spreadsheet_file.get('exportLinks') downloadurl = links.get('application/vnd.openxmlformats-officedocument.spreadsheetml.sheet') resp, content = self.client._http.request(downloadurl) return content def generate_static_site(self, output_root=None, extra_context=None): """ Bake out static site """ self.app.config['BUILD_PATH'] = output_root # use this hook for registering URLs to freeze self.call_hook("generate", self, output_root, extra_context) if output_root is not None: # realpath or this gets generated relative to the tarbell package self.app.config['FREEZER_DESTINATION'] = os.path.realpath(output_root) self.freezer.freeze() def filter_files(self, path): """ Exclude files based on blueprint and project configuration as well as hidden files. """ excludes = r'|'.join([fnmatch.translate(x) for x in self.project.EXCLUDES]) or r'$.' for root, dirs, files in os.walk(path, topdown=True): dirs[:] = [d for d in dirs if not re.match(excludes, d)] dirs[:] = [os.path.join(root, d) for d in dirs] rel_path = os.path.relpath(root, path) paths = [] for f in files: if rel_path == '.': file_path = f else: file_path = os.path.join(rel_path, f) if not re.match(excludes, file_path): paths.append(f) files[:] = paths yield root, dirs, files def find_files(self): """ Find all file paths for publishing, yield (urlname, kwargs) """ # yield blueprint paths first if getattr(self, 'blueprint_name', None): for path in walk_directory(os.path.join(self.path, self.blueprint_name), ignore=self.project.EXCLUDES): yield 'preview', {'path': path} # then yield project paths for path in walk_directory(self.path, ignore=self.project.EXCLUDES): yield 'preview', {'path': path}
def freeze(args): "https://pythonhosted.org/Frozen-Flask/" from flask_frozen import Freezer _setup_app(args) freezer = Freezer(app) freezer.freeze(debug=args.debug)
from countpool import app from flask_frozen import Freezer static_app = Freezer(app) if __name__ == "__main__": static_app.freeze()
from flask_frozen import Freezer from showcase import app freezer = Freezer(app) if __name__ == '__main__': freezer.freeze();
@freezer.register_generator def asset(): for filename in walk_directory(path.join(root_folder, "assets")): yield {'path': filename} @app.route('/<path:page_path>') def get_index_page(page_path): """ Handle requests which urls don't end with '.html' (for example, '/doc/') We don't need any generator here, because such urls are equivalent to the same urls with 'index.html' at the end. :param page_path: str :return: str """ if not page_path.endswith('/'): page_path += '/' return process_page(page_path + 'index') if __name__ == '__main__': if len(sys.argv) > 1 and sys.argv[1] == "build": urls = freezer.freeze() if not ignore_stdlib: generate_sitemap(urls) else: app.run(host="0.0.0.0", debug=True, threaded=True)
from flask_frozen import Freezer from app import app app_freezer = Freezer(app) if __name__ == '__main__': app_freezer.freeze()
def freeze(config, urls_file=None): """Freeze the application by creating a static version of it.""" if urls_file: app = make_app(config=config, URLS_FILE=urls_file) else: app = make_app(config=config) app.logger.info('freezing app to directory: %s' % app.config['FREEZER_DESTINATION']) freezer = Freezer(app) #@freezer.register_generator #def index_page(): # for (dirpath, dirnames, filenames) in os.walk(app.config['DATA_PATH'], topdown=True): # start = len(os.path.commonprefix((app.config['DATA_PATH'], dirpath))) # relative_path = dirpath[start+1:] # for dirname in dirnames: # yield ('page.index_page', {'uri': os.path.join(relative_path, dirname)}) #@freezer.register_generator #def page_uri(): # # uri_index will be used so just avoid showing a warning # return [ # ('public.page_uri', {'uri': ''}), # ] @freezer.register_generator def uri_index(): def cleanup_url(url): url = url.strip() if url.startswith('/'): if url.endswith('/index.html'): return url elif url.endswith('/'): url = url.strip('/') if len(url) == 0: return ('public.index', {}) return ('public.uri_index', {'uri': url}) try: result = db.execute(text(fetch_query_string('select_paths_to_freeze.sql'))).fetchall() except (DatabaseError, StatementError) as err: app.logger.error("DatabaseError: %s", err) return [] urls = filter(None, map(lambda x:cleanup_url(x[0]), result)) urls_file = app.config.get('URLS_FILE', None) if urls_file: urls_file = urls_file if urls_file[0] == os.sep else os.path.join(os.getcwd(), urls_file) f = open(urls_file, 'r') urls.extend(filter(None, map(cleanup_url, f.readlines()))) f.close() return urls @freezer.register_generator def send_root_file(): root_folder = app.config.get('ROOT_FOLDER', None) if root_folder and os.path.isdir( root_folder ): for (dirpath, dirnames, filenames) in os.walk(root_folder, topdown=True): start = len(os.path.commonprefix((root_folder, dirpath))) relative_path = dirpath[start+1:] for filename in filenames: yield ('send_root_file', { 'filename': os.path.join(relative_path, filename) }) @freezer.register_generator def send_media_file(): media_folder = app.config.get('MEDIA_FOLDER', None) media_path = app.config.get('MEDIA_PATH', '/media/') freeze_all_files = app.config.get('MEDIA_FREEZE_ALL', False) if media_folder and freeze_all_files and os.path.isdir( media_folder ) and media_path[0] == '/': for (dirpath, dirnames, filenames) in os.walk(media_folder, topdown=True): start = len(os.path.commonprefix((media_folder, dirpath))) relative_path = dirpath[start+1:] for filename in filenames: yield ('send_media_file', { 'filename': os.path.join(relative_path, filename) }) @freezer.register_generator def send_theme_file(): theme_static_folder = app.config.get('THEME_STATIC_FOLDER', None) theme_static_path = app.config.get('THEME_STATIC_PATH', '/theme/') if theme_static_folder and os.path.isdir( theme_static_folder ) and theme_static_path[0] == '/': for (dirpath, dirnames, filenames) in os.walk(theme_static_folder, topdown=True): start = len(os.path.commonprefix((theme_static_folder, dirpath))) relative_path = dirpath[start+1:] for filename in filenames: yield ('send_theme_file', { 'filename': os.path.join(relative_path, filename) }) freezer.freeze()
def handle(self, app): freezer = Freezer(app) freezer.register_generator(generators.theme_static) freezer.freeze()
updated = page.meta['edited'] except: updated = page.meta['date'] updated = datetime.strptime(updated, '%Y-%m-%d %H:%M +0200') date = datetime.strptime(page.meta['date'], '%Y-%m-%d %H:%M +0200') feed.add(page.title, page.html, content_type='html', url=make_external(url_for('page', path=page.path)), updated=updated, published=date) return feed.get_response() @app.route('/atom.latest') def atom_latest(): return get_feed('atom.latest', 5) @app.route('/atom.all') def atom_all(): return get_feed('atom.all') if __name__ == '__main__': """if run with build argument, generate the frozen pages else, run in debug mode""" if len(sys.argv) > 1 and sys.argv[1] == 'build': freezer.freeze() else: app.run(port=8080)
# # URLs as strings # yield '/publicar/' # @freezer.register_generator # def publicacion(): # # URLs as strings # yield '/publicacion/' # @freezer.register_generator # def publicacion2(): # # URLs as strings # yield '/publicacion2/' # @freezer.register_generator # def imagenes(): # # URLs as strings # yield '/imagenes/' # @freezer.register_generator # def casiila(): # # URLs as strings # yield '/', {'ID': '1'} # @freezer.register_generator # def salir(): # # URLs as strings # yield '/salir/' if __name__ == '__main__': freezer.freeze()