hyperflask 0.1.0__py3-none-any.whl

hyperflask/__init__.py

@@ -0,0 +1,15 @@
+from flask import *
+from .app import Hyperflask, db
+from .utils.htmx import htmx_redirect, htmx_oob
+
+# useful exports from hyperflask managed extensions
+from flask_babel import _, _p, _n, _np, lazy_gettext
+from flask_file_routes import page
+from flask_files import save_file, validate_file
+from flask_mailman_templates import send_mail
+
+# useful exports from 3rd party libs
+from htmx_flask import request, make_response
+from jinja2_fragments.flask import render_block
+from flask_apispec import use_args, use_kwargs, marshal_with
+from slugify import slugify

hyperflask/__main__.py

@@ -0,0 +1,3 @@
+from .cli import main
+
+main()

hyperflask/api.py

@@ -0,0 +1,57 @@
+import flask_apispec
+from flask_apispec.extension import FlaskApiSpec
+from flask_apispec.annotations import activate
+import functools
+import inspect
+from .resources import Resource
+
+
+class Api:
+    def __init__(self, app, version="v1", **kwargs):
+        self.url_prefix = f"/api/{version}"
+        self.endpoint_prefix = f"api_{version}_"
+        kwargs.setdefault("url_prefix", self.url_prefix)
+        kwargs.setdefault("spec_url", "/spec.json")
+        kwargs.setdefault("doc_url", "/")
+        self.app = app
+        self.docs = FlaskApiSpec(app, version=version, **kwargs)
+        self.spec = self.docs.spec
+
+    def expose(self, rule, endpoint=None, **kwargs):
+        def decorator(target):
+            nonlocal endpoint
+            if inspect.isclass(target) and issubclass(target, Resource):
+                for e in target.register(self.app, self.url_prefix, self.endpoint_prefix + (endpoint or "")):
+                    self.docs.register(self.app.view_functions[e], endpoint=e)
+            else:
+                view_func = create_view_func(target)
+                endpoint = self.endpoint_prefix + (endpoint or view_func.__name__)
+                self.app.add_url_rule(self.url_prefix + rule, endpoint, view_func, **kwargs)
+                self.docs.register(view_func, endpoint)
+            return target
+        return decorator
+
+    @staticmethod
+    def args(*args, **kwargs):
+        kwargs["activate"] = False
+        return flask_apispec.use_args(*args, **kwargs)
+
+    @staticmethod
+    def kwargs(*args, **kwargs):
+        kwargs["activate"] = False
+        return flask_apispec.use_kwargs(*args, **kwargs)
+
+    @staticmethod
+    def marshal_with(*args, **kwargs):
+        kwargs["activate"] = False
+        return flask_apispec.marshal_with(*args, **kwargs)
+
+
+def create_view_func(func):
+    @functools.wraps(func)
+    def view_func(*args, **kwargs):
+        return func(*args, **kwargs)
+    if hasattr(func, "__apispec__"):
+        view_func.__apispec__ = func.__apispec__
+        func.view_func = activate(view_func)
+    return view_func

hyperflask/app.py

@@ -0,0 +1,176 @@
+# flask
+from flask import Flask
+from jinja2 import ChoiceLoader, FileSystemLoader, PrefixLoader
+# hyperflask extensions
+from jinja_layout import LayoutExtension
+from jinja_wtforms import WtformExtension
+from flask_assets_pipeline import AssetsPipeline
+from flask_super_macros import SuperMacros
+from flask_collections import Collections
+from flask_file_routes import FileRoutes
+from flask_configurator import Config
+from flask_babel import Babel, _, _p, _n, _np, lazy_gettext
+from flask_geo import Geolocation
+from flask_files import Files
+from flask_sqlorm import FlaskSQLORM
+from flask_mercure_sse import MercureSSE
+from flask_mailman_templates import MailTemplates
+from flask_observability import Observability
+# 3rd party extensions
+from flask_wtf.csrf import CSRFProtect
+from flask_talisman import Talisman
+from flask_frozen import Freezer
+from htmx_flask import Htmx
+from flask_mailman import Mail
+from flask_dramatiq import Dramatiq
+from flask_debugtoolbar import DebugToolbarExtension
+# from hyperflask
+from .forms import Form
+from .utils.page_actions import page_action_url
+from .utils.htmx import htmx_oob
+from .components import register_components
+from . import page_helpers
+# others
+from jinja_super_macros.registry import FileLoader
+from jinja_wtforms.extractor import map_jinja_call_node_to_func
+from sqlorm.sql_template import SQLTemplate
+from periodiq import PeriodiqMiddleware
+import os
+
+
+db = FlaskSQLORM()
+
+
+map_jinja_call_node_to_func(_)
+map_jinja_call_node_to_func(_p)
+map_jinja_call_node_to_func(_n)
+map_jinja_call_node_to_func(_np)
+map_jinja_call_node_to_func(lazy_gettext)
+
+
+class Hyperflask(Flask):
+    config_class = Config
+
+    def __init__(self, *args, static_mode="hybrid", instrument=False, layouts_folder="layouts", partials_folder="partials",
+                 emails_folder="emails", forms_folder="forms", assets_folder="assets", pages_folder="pages", migrations_folder="migrations",
+                 config=None, config_filename="config.yml", **kwargs):
+        super().__init__(*args, **kwargs)
+
+        self.config.update({
+            "FREEZER_DESTINATION": os.path.join(self.root_path, "_site"),
+            "FREEZER_STATIC_IGNORE": [],
+            "WTF_CSRF_CHECK_DEFAULT": False,
+            "OTEL_INSTRUMENT": instrument,
+            "DRAMATIQ_BROKER": "dramatiq.brokers.redis:RedisBroker",
+            "DEBUG_TB_INTERCEPT_REDIRECTS": False,
+            "PAGES_MARKDOWN_OPTIONS": {"extensions": ["fenced_code", "nl2br", "attr_list", "admonition", "codehilite"]},
+            # Hyperflask specific
+            "LAYOUT": "layout.html",
+            "STATIC_MODE": static_mode,
+            "ASSETS_INCLUDE_HTMX": True,
+            "HTMX_BOOST_SITE": False
+        })
+        if config:
+            self.config.update(config)
+        if config_filename:
+            self.config.load(config_filename)
+        if self.debug:
+            self.config.setdefault("MAIL_BACKEND", "console")
+
+        self.otel = Observability(self)
+
+        self.jinja_env.add_extension(LayoutExtension)
+        self.jinja_env.add_extension(WtformExtension)
+        self.jinja_env.form_base_cls = Form
+        self.jinja_env.default_layout = self.config["LAYOUT"]
+        self.forms = self.jinja_env.forms
+
+        self.jinja_env.loader = ChoiceLoader([self.jinja_env.loader])
+        if layouts_folder and os.path.exists(os.path.join(self.root_path, layouts_folder)):
+            layout_loader = FileSystemLoader(os.path.join(self.root_path, layouts_folder))
+            self.jinja_env.loader.loaders.append(layout_loader)
+            self.jinja_env.loader.loaders.append(PrefixLoader({os.path.basename(layouts_folder): layout_loader}))
+        self.jinja_env.loader.loaders.extend([
+            FileLoader(os.path.join(os.path.dirname(__file__), "layout.html")),
+            FileLoader(os.path.join(os.path.dirname(__file__), "layout.html"), "hyperflask_layout.html"),
+            PrefixLoader({"ui": FileSystemLoader(os.path.join(os.path.dirname(__file__), "ui"))})
+        ])
+
+        DebugToolbarExtension(self)
+        self.freezer = Freezer(self)
+        self.csrf = CSRFProtect(self)
+        #self.talisman = Talisman(self)
+        Htmx(self)
+        Mail(self)
+        self.dramatiq = Dramatiq(self)
+        self.dramatiq.broker.add_middleware(PeriodiqMiddleware())
+        self.actor = self.dramatiq.actor
+
+        SuperMacros(self)
+        Babel(self)
+        Geolocation(self)
+        Files(self)
+        MailTemplates(self, template_folder=emails_folder)
+        file_routes = FileRoutes(self, pages_folder=pages_folder, partials_folder=partials_folder)
+        self.page_helper = file_routes.page_helper
+        self.collections = Collections(self)
+        MercureSSE(self)
+
+        self.assets = AssetsPipeline(self, assets_folder=assets_folder, inline=True, include_inline_on_demand=False)
+        self.assets.state.watch_template_folders.extend([
+            os.path.join(self.root_path, "pages"),
+            os.path.join(self.root_path, "macros"),
+            os.path.join(self.root_path, "components"),
+            os.path.join(self.root_path, "forms")
+        ])
+        self.assets.state.esbuild_aliases.update({
+            "assets": self.assets.state.assets_folder,
+            "@hyperflask": os.path.abspath(os.path.join(os.path.dirname(__file__), "static"))
+        })
+        self.assets.state.tailwind_suggested_content.extend(filter(bool, [
+            os.path.join(os.path.dirname(__file__), "ui") + "/**/*.html",
+            os.path.join(self.root_path, pages_folder) + "/**/*.html" if pages_folder else None,
+            os.path.join(self.root_path, pages_folder) + "/**/*.jpy" if pages_folder else None,
+            os.path.join(self.root_path, partials_folder) + "/**/*.html" if partials_folder else None,
+            os.path.join(self.root_path, partials_folder) + "/**/*.jpy" if partials_folder else None,
+            os.path.join(self.root_path, layouts_folder) + "/**/*.html" if layouts_folder else None,
+            os.path.join(self.root_path, "components") + "/**/*.html",
+            os.path.join(self.root_path, "components") + "/**/*.jpy",
+        ]))
+        self.assets.state.copy_files_from_node_modules.update({
+            "bootstrap-icons/font": "bootstrap-icons"
+        })
+        self.assets.bundle(
+            {"@hyperflask": ["app.js"],
+             "@hyperflask/reactive": ["reactive.js"],
+             "@hyperflask/alpine": ["alpine.js"]},
+            assets_folder=os.path.join(os.path.dirname(__file__), "static")
+        )
+        self.assets.include("@hyperflask", 0)
+
+        self.macros.register_from_directory(os.path.join(os.path.dirname(__file__), "ui"))
+        if hasattr(file_routes, "loader"):
+            self.forms.register_from_loader(file_routes.loader, "pages")
+        self.macros.create_from_func(htmx_oob, "HtmxOob", receive_caller=True, caller_alias="html")
+        register_components(self)
+
+        if forms_folder and os.path.isdir(os.path.join(self.root_path, forms_folder)):
+            for macro in self.macros.create_from_directory(os.path.join(self.root_path, forms_folder)):
+                self.forms.register(self.macros.resolve_template(macro), macro)
+
+        self.jinja_env.globals.update(page_action_url=page_action_url)
+
+        self.collections.register_freezer_generator(self.freezer)
+
+        SQLTemplate.eval_globals.update(app=self)
+        db.init_app(self, migrations_folder=migrations_folder)
+
+
+def static(func):
+    pass
+
+
+def dynamic(func=None, static_template=None):
+    def decorator(func):
+        pass
+    return decorator(func) if func else decorator

hyperflask/cli.py

@@ -0,0 +1,140 @@
+from flask import current_app
+from flask.cli import FlaskGroup, shell_command, routes_command, _debug_option, pass_script_info, run_command as flask_run_command, ScriptInfo, NoAppException
+from flask_assets_pipeline import cli as assets_cli
+import click
+import os
+import sys
+import multiprocessing
+import gunicorn.app.base
+from .factory import load_config, create_app
+
+
+def _create_app():
+    info = ScriptInfo()
+    try:
+        return info.load_app()
+    except NoAppException:
+        raise
+        return create_app()
+
+
+cli = FlaskGroup(name='kantree', help='Kantree', add_default_commands=False, create_app=_create_app)
+cli.add_command(shell_command)
+cli.add_command(routes_command)
+
+
+@click.command("freeze")
+def freeze_command():
+    current_app.freezer.freeze()
+
+
+@click.command("build")
+@click.pass_context
+def build_command(ctx):
+    ctx.invoke(assets_cli.build)
+
+
+@click.command("serve")
+@click.option('--gunicorn-opt', multiple=True)
+@pass_script_info
+@click.pass_context
+def serve_command(ctx, info, host, port, gunicorn_opt, **run_kwargs):
+    if os.environ.get("FLASK_DEBUG") == "1":
+        ctx.invoke(flask_run_command, host=host, port=port, **run_kwargs)
+    else:
+        options = {
+            'proc_name': 'hyperflask',
+            'bind': f'{host}:{port}',
+            'workers': 1 + multiprocessing.cpu_count() * 2,
+            'accesslog': '-',
+            'errorlog': '-',
+            'max_requests': 1000,
+            'max_requests_jitter': 100
+        }
+        for opt in gunicorn_opt:
+            key, value = opt.split('=', 1)
+            options[key] = int(value) if value.isdigit() else value
+        GunicornServer(info.load_app, options).run()
+
+
+serve_command.params = flask_run_command.params + serve_command.params
+cli.add_command(serve_command)
+
+
+@click.command("run")
+@click.argument('processes', nargs=-1)
+@click.option('--port', type=int, default=5000)
+@click.option('--concurrency')
+@click.option("--dev", is_flag=True)
+def run_command(processes, port, concurrency, dev):
+    from honcho.command import _procfile, _parse_concurrency
+    from honcho.manager import Manager
+    from honcho.printer import Printer
+    from honcho import environ
+
+    if dev:
+        os.environ["FLASK_DEBUG"] = "1"
+
+    _processes = None
+    config = load_config()
+    for filename in [f"Procfile.{config['ENV']}", "Procfile"]:
+        if os.path.exists(filename):
+            _processes = _procfile(filename).processes
+            break
+    if _processes is None:
+        _processes = {
+            "web": [sys.argv[0], "serve", "--port", "$PORT"],
+            # "worker": [sys.argv[0], "worker"],
+            # "scheduler": [sys.argv[0], "periodiq"]
+        }
+        if dev:
+            _processes["assets"] = [sys.argv[0], "assets", "dev"]
+
+    processes = {name: " ".join(_processes[name]) if isinstance(_processes[name], list) else _processes[name]
+                 for name in _processes if name in _processes}
+
+    manager = Manager(Printer(sys.stdout, colour=True))
+
+    for p in environ.expand_processes(processes,
+                                      concurrency=_parse_concurrency(concurrency),
+                                      port=port):
+        e = os.environ.copy()
+        e.update(p.env)
+        manager.add_process(p.name, p.cmd, quiet=p.quiet, env=e)
+
+    manager.loop()
+    sys.exit(manager.returncode)
+
+
+run_command.params.insert(0, _debug_option)
+cli.add_command(run_command)
+
+
+@click.command("dev")
+@click.pass_context
+def dev_command(ctx, **kwargs):
+    ctx.forward(run_command, dev=True)
+
+
+dev_command.params = list(run_command.params)
+cli.add_command(dev_command)
+
+
+def main():
+    cli.main()
+
+
+class GunicornServer(gunicorn.app.base.BaseApplication):
+    def __init__(self, app_loader, options=None):
+        self.app_loader = app_loader
+        self.options = options or {}
+        super().__init__()
+
+    def load_config(self):
+        config = {key: value for key, value in self.options.items()
+                  if key in self.cfg.settings and value is not None}
+        for key, value in config.items():
+            self.cfg.set(key.lower(), value)
+
+    def load(self):
+        return self.app_loader()

hyperflask/components/__init__.py

@@ -0,0 +1,54 @@
+import jinjapy
+import importlib
+import os
+import importlib
+import re
+from importlib.metadata import entry_points
+from .core import ComponentAdapter
+from .alpine import AlpineAdapter
+from .webcomponent import WebComponentAdapter
+
+
+def register_components(app, path=None, package_name=None):
+    if not path:
+        path = os.path.join(app.root_path, "components")
+        if not os.path.exists(path):
+            return
+    if not package_name:
+        package_name = "components"
+        if app.import_name != "__main__":
+            package_name = f"{app.import_name}.{package_name}"
+
+    url_prefix = "/__components/"
+    adapters = list(list_available_adapters())
+    force_adapters = app.config.get("COMPONENT_ADAPTERS", {})
+
+    loader = jinjapy.register_package(package_name, path, env=app.jinja_env)
+    for module_name, template in loader.list_files(module_with_package=False):
+        adapter_class = None
+        for pattern, adapter_import_path in force_adapters.items():
+            if re.match(pattern, template):
+                adapter_module, adapter_classname = adapter_import_path.split(":")
+                adapter_class = getattr(importlib.import_module(adapter_module), adapter_classname)
+                break
+        if not adapter_class:
+            matches = False
+            for adapter_class in adapters:
+                if adapter_class.matches(app, module_name, template):
+                    matches = True
+                    break
+            if not matches:
+                continue
+        if adapter_class:
+            name = os.path.basename(template).split(".")[0].replace("-", "_")
+            adapter = adapter_class(name, f"{package_name}.{module_name}" if module_name else None, template)
+            adapter.register(app, url_prefix)
+            app.macros.create_from_func(adapter.render, name, receive_caller=True)
+
+
+def list_available_adapters():
+    yield AlpineAdapter
+    yield WebComponentAdapter
+    for entry in entry_points(group="hyperflask.component_adapters"):
+        yield entry.load()
+    yield ComponentAdapter

hyperflask/components/alpine.py

@@ -0,0 +1,16 @@
+from .core import ComponentAdapter
+from flask import current_app
+
+
+class AlpineAdapter(ComponentAdapter):
+    @classmethod
+    def matches(cls, app, module_name, template):
+        if not ComponentAdapter.matches(app, module_name, template):
+            return False
+        tpl = app.jinja_env.loader.get_source(app.jinja_env, template)[0]
+        tags = ["x-data", "x-init", "x-show", "x-bind", "x-model", "x-text", "x-html", "x-if", "x-for", "x-on"]
+        return any(tag in tpl for tag in tags)
+
+    def render(self, caller, *args, **kwargs):
+        current_app.assets.include("@hyperflask/alpine")
+        return super().render(caller, *args, **kwargs)

hyperflask/components/core.py

@@ -0,0 +1,60 @@
+from markupsafe import Markup
+from flask import request, current_app
+from flask.views import http_method_funcs
+import importlib
+
+
+class BaseComponentAdapter:
+    @classmethod
+    def matches(cls, app, module_name, template):
+        return False
+
+    def __init__(self, name, module_name, template):
+        self.name = name
+        self.module_name = module_name
+        self.template = template
+
+    def register(self, app, url_prefix):
+        pass
+
+    def render(self, caller, *args, **kwargs):
+        tpl = current_app.jinja_env.get_template(self.template)
+        ctx = dict(args=args, kwargs=kwargs, props=kwargs, caller=caller)
+        return Markup(tpl.render(**ctx))
+
+
+class ComponentAdapter(BaseComponentAdapter):
+    @classmethod
+    def matches(cls, app, module_name, template):
+        return module_name or template.endswith(".html") or template.endswith(".jpy")
+
+    def register(self, app, url_prefix):
+        if not self.module_name:
+            return
+        url = url_prefix + self.name.replace("_", "/")
+        module = importlib.import_module(self.module_name)
+        methods = [m.upper() for m in http_method_funcs if m in dir(module)]
+        def view_func():
+            props = {}
+            module = importlib.import_module(self.module_name)
+            m = getattr(module, request.method.lower(), None)
+            if m:
+                props = m()
+                if props is not None and not isinstance(props, dict):
+                    return props
+                if not props:
+                    props = {}
+            return app.macros[self.name](**props)
+        if methods:
+            app.add_url_rule(url, self.name, view_func=view_func, methods=methods)
+
+    def render(self, caller, *args, **kwargs):
+        tpl = current_app.jinja_env.get_template(self.template)
+        ctx = dict(args=args, kwargs=kwargs, props=kwargs, caller=caller)
+        if self.module_name:
+            module = importlib.import_module(self.module_name)
+            if module and "render" in dir(module):
+                _ctx = module.render(*args, **kwargs)
+                if _ctx:
+                    ctx.update(_ctx)
+        return Markup(tpl.render(**ctx))

hyperflask/components/webcomponent.py

@@ -0,0 +1,23 @@
+from .core import BaseComponentAdapter
+from jinja_super_macros import html_tag
+from flask import current_app
+from markupsafe import Markup
+import os
+
+
+class WebComponentAdapter(BaseComponentAdapter):
+    @classmethod
+    def matches(cls, app, module_name, template):
+        return template.endswith(".js")
+
+    def register(self, app, url_prefix):
+        tpl = app.jinja_env.get_template(self.template)
+        if "@components" not in app.assets.state.bundles:
+            app.assets.state.bundles["@components"] = []
+        app.assets.state.bundles["@components"].append(
+            app.assets.format_bundle_file(os.path.abspath(tpl.filename), self.template))
+    
+    def render(self, caller, *args, **kwargs):
+        current_app.assets.include("@components")
+        tag_name = self.name.replace("_", "-")
+        return html_tag(tag_name, **kwargs) + (caller() if caller else "") + Markup(f"</{tag_name}>")