hyperflask 0.1.0__py3-none-any.whl

hyperflask/factory.py

@@ -0,0 +1,173 @@
+from .app import Hyperflask, db
+from .resources import Resource
+from .api import Api
+from flask_configurator import Config
+import importlib
+from importlib.abc import MetaPathFinder, SourceLoader
+from importlib.util import spec_from_file_location
+from importlib.machinery import SourceFileLoader
+from importlib.metadata import entry_points
+import logging
+import os
+import sys
+import runpy
+
+
+app = None
+api = None
+
+
+def load_config(root_path=None):
+    debug = os.environ.get("FLASK_DEBUG") == "1"
+    default_env = "development" if debug else "production"
+    config = Config(root_path, defaults={
+        "SQLORM_URI": "sqlite://app.db"
+    })
+    config.load("config.yml", default_env)
+    if config["ENV"] == "development" and not config.get("SECRET_KEY"):
+        logging.getLogger().warn("Missing SECRET_KEY has been automatically set to 'changeme' while in development mode")
+        config["SECRET_KEY"] = "changeme"
+    return config
+
+
+def create_app(root_path=None):
+    global app
+    global api
+    config = load_config(root_path)
+    static_folder = config.get("STATIC_FOLDER", "public")
+    migrations_folder = config.get("MIGRATIONS_FOLDER", "migrations")
+
+    if root_path is None:
+        root_path = os.getcwd()
+
+    if os.path.exists(os.path.join(root_path, "app")):
+        static_folder = os.path.abspath(os.path.join(root_path, static_folder))
+        migrations_folder = os.path.abspath(os.path.join(root_path, migrations_folder))
+        import_name = "app"
+        root_path = os.path.join(root_path, "app")
+        sys.meta_path.insert(0, VirtualPackageFinder(import_name, root_path))
+    else:
+        import_name = "__main__"
+
+    app = Hyperflask(import_name, root_path=root_path, config=config, static_folder=static_folder,
+                     static_url_path=config.get("STATIC_URL_PATH", "/static"),
+                     migrations_folder=migrations_folder)
+    
+    api = Api(app)
+
+    if app.config.get("LOAD_HYPERFLASK_EXTENSIONS", True):
+        for entry in entry_points(group="hyperflask.extensions"):
+            entry.load()(app)
+
+    extensions = {}
+    if "FLASK_EXTENSIONS" in app.config:
+        extensions.update(dict([ext.items()[0] if isinstance(ext, dict) else (ext, {}) for ext in app.config["FLASK_EXTENSIONS"]]))
+
+    for ext, config in extensions.items():
+        module, class_name = ext.rsplit(":", 1)
+        m = importlib.import_module(module)
+        getattr(m, class_name)(app, **config)
+
+    try_import(app, "models")
+    try_import(app, "routes")
+    try_import(app, "api")
+    try_import(app, "tasks")
+    try_import(app, "cron")
+
+    resources = try_import(app, "resources")
+    if resources:
+        for name in dir(resources):
+            obj = getattr(resources, name)
+            if issubclass(obj, Resource) and obj.url_prefix:
+                obj.register(app, api)
+
+    db.init_db()
+    return app
+
+
+def try_import(app, name, import_submodules=True):
+    if app.import_name != "__main__":
+        name = f"{app.import_name}.{name}"
+    try:
+        mod = importlib.import_module(name)
+
+        if import_submodules:
+            is_virtual_package = os.path.isdir(os.path.join(app.root_path, name)) and not os.path.exists(os.path.join(app.root_path, name, "__init__.py"))
+            if is_virtual_package:
+                mod = {}
+                for f in os.listdir(os.path.join(app.root_path, name)):
+                    if f.endswith(".py"):
+                        m = importlib.import_module(f"{name}.{f.rsplit('.', 1)[0]}")
+                        mod.update({k: getattr(m, k) for k in dir(m) if not k.startswith("_")})
+                return mod
+
+        return {k: getattr(mod, k) for k in dir(mod) if not k.startswith("_")}
+    except ImportError:
+        return
+    
+
+def get_factory_package(name):
+    tasks_dir = os.path.join(app.root_path, name)
+    if not os.path.exists(os.path.join(app.root_path, f"{name}.py")) and os.path.isdir(tasks_dir) and not os.path.exists(os.path.join(tasks_dir, "__init__.py")):
+        return tasks_dir
+    return False
+
+
+def create_task_from_file(app, filename, **kwargs):
+    kwargs["actor_name"] = os.path.basename(filename).rsplit(".", 1)[0]
+    @app.actor(**kwargs)
+    def actor():
+        runpy.run_path(filename)
+
+
+def extract_cron_schedule_from_file(filename):
+    with open(filename) as f:
+        line = f.readline()
+        if not line.startswith("#"):
+            raise Exception("Cronjobs must start with a comment line specifying the schedule")
+        return line[1:].strip()
+
+
+class VirtualPackageFinder(MetaPathFinder):
+    def __init__(self, package_name, path=None):
+        if not path:
+            path = os.path.join(os.getcwd(), package_name.replace(".", "/"))
+        self.package_name = package_name
+        self.path = path
+
+    def find_spec(self, fullname, path, target=None):
+        if not fullname.startswith(self.package_name):
+            return
+        
+        if fullname == self.package_name:
+            relname = ""
+        else:
+            relname = fullname[len(self.package_name)+1:].replace(".", "/")
+
+        if os.path.isdir(os.path.join(self.path, relname)):
+            filename = os.path.join(self.path, relname, "__init__.py")
+            loader_class = SourceFileLoader if os.path.exists(filename) else EmptyFileLoader
+            return spec_from_file_location(fullname, filename, loader=loader_class(fullname, filename),
+                submodule_search_locations=[os.path.join(self.path, relname)])
+        
+        filename = os.path.join(self.path, f"{relname}.py")
+        if os.path.exists(filename):
+            return spec_from_file_location(fullname, filename, loader=SourceFileLoader(fullname, filename),
+                                            submodule_search_locations=None)
+        
+
+
+class EmptyFileLoader(SourceLoader):
+    def __init__(self, fullname, filename):
+        self.fullname = fullname
+        self.filename = filename
+
+    def get_filename(self, fullname):
+        return self.filename
+
+    def get_data(self, filename):
+        return ""
+    
+
+if __name__ == "__main__":
+    create_app()

hyperflask/forms/__init__.py

@@ -0,0 +1,51 @@
+from wtforms import validators, ValidationError
+from wtforms.fields import *
+from wtforms.csrf.core import CSRFTokenField
+from flask_wtf import FlaskForm
+from flask import abort
+from jinja_wtforms.form import TEMPLATE_FORM_FIELDS
+from .fields import *
+
+
+TEMPLATE_FORM_FIELDS.update({
+    "checkbox": BooleanField,
+    "decimal": DecimalField,
+    "date": DateField,
+    "datetime": DateTimeField,
+    "float": FloatField,
+    "int": IntegerField,
+    "radio": RadioField,
+    "select": SelectField,
+    "selectmulti": SelectMultipleField,
+    "text": StringField,
+    "textarea": TextAreaField,
+    "password": PasswordField,
+    "hidden": HiddenField,
+    "datetimelocal": DateTimeLocalField,
+    "decimalrange": DecimalRangeField,
+    "email": EmailField,
+    "intrange": IntegerRangeField,
+    "search": SearchField,
+    "tel": TelField,
+    "url": URLField,
+    "file": FileField,
+    "files": MultipleFileField
+})
+
+
+class Form(FlaskForm):
+    def validate_or_400(self):
+        if not self.validate():
+            abort(400)
+
+    def populate_obj(self, obj):
+        for name, field in self._fields.items():
+            if not isinstance(field, CSRFTokenField):
+                field.populate_obj(obj, name)
+
+    @property
+    def data(self):
+        return {name: f.data for name, f in self._fields.items() if not isinstance(f, CSRFTokenField)}
+
+    def data_without(self, *fields):
+        return {name: f.data for name, f in self._fields.items() if name not in fields and not isinstance(f, CSRFTokenField)}

hyperflask/forms/fields.py

@@ -0,0 +1,17 @@
+from . import widgets
+from wtforms import fields
+
+
+__all__ = ('StringField', 'PasswordField', 'EmailField')
+
+
+class StringField(fields.StringField):
+    widget = widgets.TextInput()
+
+
+class PasswordField(fields.PasswordField):
+    widget = widgets.PasswordInput()
+
+
+class EmailField(fields.StringField):
+    widget = widgets.EmailInput()

hyperflask/forms/widgets.py

@@ -0,0 +1,19 @@
+from wtforms import widgets
+
+
+def create_input_class(basecls):
+    class Input(basecls):
+        def __call__(self, field, **kwargs):
+            extend_class(kwargs, "input input-bordered w-full")
+            return super().__call__(field, **kwargs)
+    return Input
+
+
+TextInput = create_input_class(widgets.TextInput)
+PasswordInput = create_input_class(widgets.PasswordInput)
+EmailInput = create_input_class(widgets.EmailInput)
+
+
+def extend_class(kwargs, classes):
+    c = kwargs.pop('class', '') or kwargs.pop('class_', '')
+    kwargs['class'] = '%s %s' % (classes, c)

hyperflask/layout.html

@@ -0,0 +1,28 @@
+<!DOCTYPE html>
+<html lang="{{config.get("SITE_LANG", "en")}}" {% block html_tag_attrs %}{% endblock %}>
+    <head>
+        {% block head -%}
+        {% block head_metas %}
+        <meta charset="utf-8">
+        <meta name="viewport" content="width=device-width, initial-scale=1">
+        {% endblock %}
+        {% if config["PWA"] -%}
+        <link rel="manifest" href="{{url_for("pwa_manifest")}}" />
+        {%- endif %}
+        {% block page_title %}<title>{% if page_title is defined %}{{ page_title }}{% if config.get("SITE_TITLE") %} | {% endif %}{% endif %}{% if config.get("SITE_TITLE") %}{{config["SITE_TITLE"]}}{% endif %}</title>{% endblock %}
+        {% asset_tags %}
+        {% block head_assets %}{% endblock %}
+        {%- endblock %}
+    </head>
+    {% block body_tag -%}
+    <body
+        {% if config["HTMX_BOOST_SITE"] %}hx-boost="true"{% endif %}
+        {% if config["PWA"] %}hx-ext="pwa" pwa-service-worker="{{url_for('pwa_service_worker')}}"{% endif %}
+        {% block body_tag_attrs %}{% endblock %}
+    >
+    {%- endblock %}
+        {% block body %}{% block content %}{% endblock %}{% endblock %}
+        {% block footer %}{% endblock %}
+        {% block body_end %}{% endblock %}
+    </body>
+</html>

hyperflask/page_helpers.py

@@ -0,0 +1,36 @@
+from flask_file_routes import DEFAULT_HELPERS
+from flask import g, current_app
+from .utils.page_actions import page_action
+
+
+def csrf_protect(page):
+    current_app.csrf.protect()
+
+
+def forms(page):
+    return current_app.forms[page.template]
+
+
+def form(page):
+    def form_helper(template=None, **kwargs):
+        page.form = current_app.forms[template or page.template](**kwargs)
+        return page.form
+    return form_helper
+
+
+def stream(page):
+    g.__page_stream__ = True
+    return
+
+
+def action(page):
+    def decorator(func=None, name=None):
+        return page_action(func, name)
+    return decorator
+
+
+DEFAULT_HELPERS.update(csrf_protect=csrf_protect,
+                       forms=forms,
+                       form=form,
+                       stream=stream,
+                       action=action)

hyperflask/reactivity.py

@@ -0,0 +1,46 @@
+from jinja2.ext import Extension
+from jinja_super_macros import html_tag
+from flask import current_app
+from .resources import ResourceList, Resource
+
+
+def reactive(obj, attr=None):
+    if attr and hasattr(getattr(obj, attr), "__reactive__"):
+        obj = getattr(obj, attr)
+        attr = None
+    elif not hasattr(obj, "__reactive__"):
+        return getattr(obj, attr) if attr else obj
+    
+    current_app.assets.include("@hyperflask/reactive")
+
+    mercure_topic, many = obj.__reactive__()
+    
+    if many:
+        if attr:
+            raise Exception("Cannot access attribute of a ResourceList")
+        return html_tag("div", {"x-reactive-list": obj.resource.name})
+    
+    return html_tag("span", {"x-reactive-prop": obj.resource.name, "data-attr": attr})
+
+
+class ReactiveExtension(Extension):
+    def __init__(self, environment):
+        super().__init__(environment)
+        environment.globals["reactive"] = reactive
+        
+    def preprocess(self, source, name, filename=None):
+        pos = source.find("{!")
+        while pos >= 0:
+            end = source.find("!}", pos)
+            if end < 0:
+                raise Exception("Missing closing bracket for reactive")
+            value = source[pos + 2:end]
+            if "." in value:
+                obj, attr = value.rsplit(".", 1)
+                args = [obj, attr]
+            else:
+                args = [value]
+            replacement = "{{ reactive(" + ", ".join(args) + ") }}"
+            source = source[:pos] + replacement + source[end + 2:]
+            pos = source.find("{!", pos + len(replacement) + 2)
+        return source

hyperflask/resources.py

@@ -0,0 +1,149 @@
+from hyperflask import db
+from sqlorm import Model
+from flask_apispec import marshal_with, use_args
+from flask_apispec.views import MethodResource
+from werkzeug.exceptions import HTTPException
+import typing as t
+
+
+class ResourceMeta(type):
+    def __new__(cls, name, bases, attrs):
+        cls = super().__new__(cls, name, bases, attrs)
+        if not bases:
+            return cls
+
+        if not hasattr(cls, "schema"):
+            cls.schema = create_model_schema(cls.model)
+
+        return cls
+    
+
+def create_model_schema(model):
+    pass
+
+
+class ResourceError(HTTPException):
+    def __init__(self, description, code=400):
+        super().__init__(description)
+        self.code = code
+
+
+class ResourceNotFound(ResourceError):
+    def __init__(self):
+        super().__init__("URL not found", 404)
+
+
+class Resource(metaclass=ResourceMeta):
+    model: t.ClassVar[Model]
+    url_prefix = None
+    object_url_prefix = "/<id>"
+    expose_create = True
+    expose_edit = True
+    expose_methods = t.ClassVar[t.Sequence[str]]
+
+    @classmethod
+    def list(cls):
+        return ResourceList(cls, cls.model.find_all())
+
+    @classmethod
+    def create(cls, **kwargs):
+        with db:
+            return cls(cls.model.create(**kwargs))
+
+    @classmethod
+    def get(cls, id):
+        obj = cls.model.get(id)
+        if not obj:
+            raise ResourceNotFound()
+        return cls(obj)
+    
+    def __init__(self, obj):
+        self.obj = obj
+
+    def update(self, data):
+        with db:
+            self.obj.update(**data)
+
+    def delete(self):
+        with db:
+            self.obj.delete()
+
+    def __getattr__(self, name):
+        return getattr(self.obj, name)
+    
+    def __reactive__(self):
+        return
+
+    @classmethod
+    def register(cls, app, url_prefix="", endpoint_prefix=""):
+        from .api import create_view_func
+
+        @marshal_with(cls.schema(many=True))
+        def many_get():
+            return cls.list()
+        
+        @use_args(cls.schema)
+        @marshal_with(cls.schema)
+        def many_post(data):
+            return cls.create(**data)
+        
+        @marshal_with(cls.schema)
+        def single_get(id):
+            return cls.get(id)
+        
+        @use_args(cls.schema)
+        @marshal_with(cls.schema)
+        def single_put(data, id):
+            obj = cls.get(id)
+            obj.update(data)
+            return obj
+        
+        def single_delete(id):
+            obj = cls.get(id)
+            obj.delete()
+            return {}, 204
+        
+        many_methods = {"get": many_get}
+        if cls.expose_create:
+            many_methods["post"] = many_post
+        many_view = type(f"{cls.__name__}ManyView", (MethodResource,), many_methods)
+        many_endpoint = endpoint_prefix + cls.__name__.lower() + "_many"
+
+        single_methods = {"get": single_get}
+        if cls.expose_edit:
+            single_methods.update({"put": single_put, "delete": single_delete})
+        single_view = type(f"{cls.__name__}View", (MethodResource,), single_methods)
+        single_endpoint = endpoint_prefix + cls.__name__.lower()
+
+        app.add_url_rule(url_prefix + cls.url_prefix, view_func=many_view.as_view(many_endpoint))
+        app.add_url_rule(url_prefix + cls.url_prefix + cls.object_url_prefix, view_func=single_view.as_view(single_endpoint))
+
+        endpoints = [many_endpoint, single_endpoint]
+
+        for attr in dir(cls):
+            if hasattr(getattr(cls, attr), "__expose__"):
+                rule, endpoint, kwargs = getattr(cls, attr).__expose__
+                view_func = create_view_func(getattr(cls, attr))
+                app.add_url_rule(url_prefix + cls.url_prefix + rule, endpoint_prefix + endpoint, view_func=view_func, **kwargs)
+                endpoints.append(endpoint_prefix + endpoint)
+
+        return endpoints
+
+
+def expose(rule=None, endpoint=None, **kwargs):
+    def decorator(func):
+        func.__expose__ = (rule or func.__name__, endpoint or func.__name__, kwargs)
+        return func
+    return decorator
+
+
+class ResourceList:
+    def __init__(self, resource_class, objects):
+        self.resource_class = resource_class
+        self.objects = objects
+
+    def __iter__(self):
+        return [self.resource_class(obj) for obj in self.objects]
+    
+    def __reactive__(self):
+        return

hyperflask/static/alpine.js

@@ -0,0 +1,5 @@
+import Alpine from 'alpinejs'
+
+window.Alpine = Alpine
+
+export default Alpine

hyperflask/static/app.js

@@ -0,0 +1,5 @@
+import "./htmx"
+
+if (window.Alpine) {
+    window.Alpine.start()
+}

hyperflask/static/htmx.js

@@ -0,0 +1,5 @@
+import htmx from "htmx.org";
+
+window.htmx = htmx;
+
+export default htmx;

hyperflask/static/reactive.js

@@ -0,0 +1,5 @@
+import Alpine from "./alpine"
+
+Alpine.directive("reactive", (el, { value, modifiers, expression }, { Alpine, effect, cleanup }) => {
+    
+})

hyperflask/static/stimulus.js

@@ -0,0 +1,4 @@
+import { Application, Controller } from "@hotwired/stimulus"
+
+const Stimulus = Application.start();
+export { Stimulus, Controller };

hyperflask/static/translations.js

@@ -0,0 +1,55 @@
+
+
+export function _(text, ...args) {
+  return formatTranslationString(getCatalogValue(text)[1] || text, ...args)
+}
+
+export function _p(context, text, ...args) {
+  return formatTranslationString(getCatalogValue(text, context)[1] || text, ...args)
+}
+
+export function _n(singular, plural, count, args, context) {
+  args = args || {};
+  args['count'] = count;
+  const value = getCatalogValue(singular, context);
+  if (value) {
+    if (value[1]) {
+      singular = value[1];
+    }
+    if (value[2]) {
+      plural = value[2];
+    }
+  }
+  if (count > 1) {
+    return formatTranslationString(plural, args);
+  }
+  return formatTranslationString(singular, args);
+}
+
+export function _np(context, singular, plural, count, args) {
+  return _n(singular, plural, count, args, context);
+}
+
+function formatTranslationString(text, ...data) {
+  if (data.length) {
+    if (data.length === 1 && $.isPlainObject(data[0])) {
+      data = data[0];
+    }
+    for (let [key, value] of Object.entries(data)) {
+      text = text.replace(new RegExp('\\{' + key + '\\}', 'gi'), value);
+    }
+  }
+  return text;
+}
+
+function getCatalogValue(text, context) {
+  const messageId = context ? context + '::' + text : text;
+  if (typeof(catalog[messageId]) !== 'undefined' && catalog[messageId][1]) {
+    return catalog[messageId];
+  }
+  return [null, null];
+}
+
+export function getCurrentLocale() {
+  
+}

hyperflask/ui/components/README.md

@@ -0,0 +1,3 @@
+[DaisyUI](https://daisyui.com) components generated from [uilibspec-daisyui](https:/github.com/hyperflask/uilib-spec-daisyui) using [uilibspec](https:/github.com/hyperflask/uilib-spec)
+
+This folder is auto-generated!

hyperflask/ui/components/actions/Button.html

@@ -0,0 +1,6 @@
+{% macro Button(style=None, active=None, outline=None, size=None, wide=None, glass=None) -%}
+    <button class="btn {{kwargs.pop('class', '')}} {% if style %} btn-{{style}}{% endif %} {% if active %} btn-active{% endif %} {% if outline %} btn-outline{% endif %} {% if size %} btn-{{size}}{% endif %} {% if wide %} btn-wide{% endif %} {% if glass %} glass{% endif %}" {{ html_attrs(kwargs) }}>
+        {{ caller() }}
+        
+    </button>
+{%- endmacro %}

hyperflask/ui/components/actions/Dropdown.html

@@ -0,0 +1,16 @@
+{% macro Dropdown() -%}
+    <div class="dropdown">
+        
+        <div tabindex="0" role="button" class="btn m-1">
+            Click
+        </div>
+        
+        <ul tabindex="0" class="dropdown-content z-[1] menu p-2 shadow bg-base-100 rounded-box w-52">
+            
+            {{ caller() }}
+            
+            
+        </ul>
+        
+    </div>
+{%- endmacro %}

hyperflask/ui/components/actions/DropdownItem.html

@@ -0,0 +1,8 @@
+{% macro DropdownItem() -%}
+    <li >
+        <a >
+            {{ caller() }}
+            
+        </a>
+    </li>
+{%- endmacro %}

hyperflask/ui/components/actions/LinkButton.html

@@ -0,0 +1,6 @@
+{% macro LinkButton(style=None, active=None, outline=None, size=None, wide=None, glass=None) -%}
+    <a class="btn {{kwargs.pop('class', '')}} {% if style %} btn-{{style}}{% endif %} {% if active %} btn-active{% endif %} {% if outline %} btn-outline{% endif %} {% if size %} btn-{{size}}{% endif %} {% if wide %} btn-wide{% endif %} {% if glass %} glass{% endif %}" {{ html_attrs(kwargs) }}>
+        {{ caller() }}
+        
+    </a>
+{%- endmacro %}