flaskteroids 0.1.0__py3-none-any.whl

flaskteroids/__init__.py

@@ -0,0 +1,31 @@
+from flask import redirect
+from flaskteroids.actions import params
+from flaskteroids.flash import flash
+from flaskteroids.rules import rules
+from importlib.metadata import PackageNotFoundError, version as _version
+
+
+try:
+    __version__ = _version("flaskteroids")
+except PackageNotFoundError:
+    # This means that package is not installed
+    __version__ = None
+
+
+def redirect_to(target, **kwargs):
+    notice = kwargs.pop('notice', None)
+    if notice:
+        flash['notice'] = notice
+    alert = kwargs.pop('alert', None)
+    if alert:
+        flash['alert'] = alert
+    status = kwargs.get('status') or 302
+    return redirect(target, code=status)
+
+
+__all__ = [
+    'params',
+    'flash',
+    'rules',
+    'redirect_to'
+]

flaskteroids/__main__.py

@@ -0,0 +1,5 @@
+from flaskteroids.cli.flaskteroids import cli
+
+
+if __name__ == "__main__":
+    cli()

flaskteroids/actions.py

@@ -0,0 +1,207 @@
+import logging
+import re
+from werkzeug.local import LocalProxy
+from functools import wraps
+from typing import Any
+from collections import UserDict, defaultdict
+from flask import g
+from flaskteroids import registry
+from flaskteroids.exceptions import InvalidParameter, MissingParameter, ProgrammerError
+from flaskteroids.discovery import discover_methods
+
+
+_logger = logging.getLogger(__name__)
+
+
+def register_actions(cls, base_cls):
+    ns = registry.get(cls)
+    ns['actions'] = discover_methods(
+        cls, ignore=set(discover_methods(base_cls))
+    )
+
+
+def get_actions(cls):
+    ns = registry.get(cls)
+    return ns.get('actions') or []
+
+
+def decorate_action(cls, action_fn):
+    @wraps(action_fn)
+    def wrapper(*args, **kwargs):
+        ns = registry.get(cls)
+        before_action = [getattr(cls, ba) for ba in ns.get('before_action', {}).get(action_fn.__name__, [])]
+        for ba in before_action:
+            res = ba(*args, **kwargs)
+            if res:
+                return res
+        around_action = [
+            getattr(cls, aa)(*args, **kwargs)
+            for aa in ns.get('around_action', {}).get(action_fn.__name__, [])
+        ]
+        for aa in around_action:
+            next(aa)
+        res = action_fn(*args, **kwargs)
+        for aa in reversed(around_action):
+            next(aa, None)
+        after_action = [getattr(cls, aa) for aa in ns.get('after_action', {}).get(action_fn.__name__, [])]
+        for aa in after_action:
+            aa(*args, **kwargs)
+        return res
+    return wrapper
+
+
+def before_action(method_name: str, *, only=None):
+    def bind(cls):
+        if not method_name.startswith('_'):
+            raise ProgrammerError('Before action methods should follow conventions for private methods')
+        getattr(cls, method_name)
+        actions = only if only else None
+        ns = registry.get(cls)
+
+        if 'before_action' not in ns:
+            ns['before_action'] = defaultdict(lambda: [])
+        if not actions:
+            actions = ns['actions'] if 'actions' in ns else []
+
+        for action_name in actions:
+            _logger.debug(f'before_action: setting {method_name} before {action_name} on {cls.__name__}')
+            ns['before_action'][action_name].append(method_name)
+    return bind
+
+
+def around_action(method_name: str, *, only=None):
+    def bind(cls):
+        if not method_name.startswith('_'):
+            raise ProgrammerError('Around action methods should follow conventions for private methods')
+        getattr(cls, method_name)
+        actions = only if only else None
+        ns = registry.get(cls)
+
+        if 'around_action' not in ns:
+            ns['around_action'] = defaultdict(lambda: [])
+        if not actions:
+            actions = ns['actions'] if 'actions' in ns else []
+
+        for action_name in actions:
+            _logger.debug(f'around_action: setting {method_name} around {action_name} on {cls.__name__}')
+            ns['around_action'][action_name].append(method_name)
+    return bind
+
+
+def after_action(method_name: str, *, only=None):
+    def bind(cls):
+        if not method_name.startswith('_'):
+            raise ProgrammerError('After action methods should follow conventions for private methods')
+        getattr(cls, method_name)
+        actions = only if only else None
+        ns = registry.get(cls)
+
+        if 'after_action' not in ns:
+            ns['after_action'] = defaultdict(lambda: [])
+        if not actions:
+            actions = ns['actions'] if 'actions' in ns else []
+
+        for action_name in actions:
+            _logger.debug(f'after_action: setting {method_name} after {action_name} on {cls.__name__}')
+            ns['after_action'][action_name].append(method_name)
+    return bind
+
+
+def skip_before_action(method_name: str, *, only=None):
+    def bind(cls):
+        ns = registry.get(cls)
+        actions = only if only else None
+        if not actions:
+            actions = ns['actions'] if 'actions' in ns else []
+        for action_name in actions:
+            if 'before_action' not in ns:
+                continue
+            if action_name not in ns['before_action']:
+                continue
+            if method_name not in ns['before_action'][action_name]:
+                continue
+            ns['before_action'][action_name].remove(method_name)
+    return bind
+
+
+class ActionParameters(UserDict):
+
+    @classmethod
+    def new(cls, params):
+        p = ActionParameters()
+        p.update(params)
+        return p
+
+    def expect(self, *args, **kwargs):
+        root = {}
+        for arg in args:
+            schema = self._schema('params', [arg])
+            root.update(self._expect('params', self.data, schema))
+        expected = [root] if root else []
+        for k, v in kwargs.items():
+            schema = self._schema(f'params.{k}', [(k, v)])
+            res = self._expect(f'params.{k}', self.data, schema)
+            expected.append(res[k])
+        if not expected:
+            return {}
+        elif len(expected) == 1:
+            return expected[0]
+        else:
+            return expected
+
+    def _schema(self, key, fields):
+        if not isinstance(fields, list):
+            raise ProgrammerError(key, 'Incorrect fields specification. Fields should always be lists')
+        schema = {}
+        for f in fields:
+            if isinstance(f, str):
+                schema[f] = Any
+            elif isinstance(f, tuple) and len(f) == 2:
+                fk, fv = f
+                if isinstance(fv, list) and len(fv) == 0:
+                    schema[fk] = list
+                elif isinstance(fv, list) and len(fv) == 1 and isinstance(fv[0], list):
+                    schema[fk] = [self._schema(fk, fv[0])]
+                else:
+                    schema[fk] = self._schema(fk, fv)
+            else:
+                raise ProgrammerError(key, 'Incorrect field specification. Field must be str / tuple')
+        return schema
+
+    def _expect(self, key, value, schema):
+        if not isinstance(value, dict):
+            raise InvalidParameter(key, 'Invalid parameter type. Not a dict')
+        expected = {}
+        for k, v in schema.items():
+            if k not in value:
+                raise MissingParameter(key, k, 'Parameter is missing')
+            elif value[k] is None:
+                expected[k] = None
+            elif v is Any:
+                if type(value[k]) not in (int, float, str, bool):
+                    raise InvalidParameter(key, k, 'Invalid parameter type. Not a scalar')
+                expected[k] = value[k]
+            elif v is list:
+                if not isinstance(value[k], list):
+                    raise InvalidParameter(key, k, 'Invalid parameter type. Not a list')
+                if any(type(vi) not in (int, float, str, bool) for vi in value[k]):
+                    raise InvalidParameter(key, k, 'Invalid parameter type. Not a scalars list')
+                expected[k] = value[k]
+            elif isinstance(v, list):
+                if not isinstance(value[k], list):
+                    raise InvalidParameter(key, k, 'Invalid parameter type. Not a list')
+                expected[k] = [self._expect(f'{key}.{k}[{i}]', vi, v[0]) for i, vi in enumerate(value[k])]
+            elif isinstance(v, dict):
+                if not isinstance(value[k], dict):
+                    raise InvalidParameter(key, k, 'Invalid parameter type. Not a dict')
+                expected[k] = self._expect(f'{key}.{k}', value[k], v)
+        return expected
+
+
+def _get_params():
+    if 'params' not in g:
+        g.params = ActionParameters()
+    return g.params
+
+
+params = LocalProxy(_get_params)

flaskteroids/app.py

@@ -0,0 +1,158 @@
+import logging
+import secrets
+from http import HTTPStatus
+from werkzeug.middleware.proxy_fix import ProxyFix
+from werkzeug.exceptions import default_exceptions
+from flask.app import Flask
+from flaskteroids.extensions.mail import MailExtension
+import flaskteroids.model as model
+from flaskteroids.db import session
+from flaskteroids.flash import flash
+from flaskteroids import helpers
+from flaskteroids.csrf import CSRFToken
+from flaskteroids.extensions.jobs import JobsExtension
+from flaskteroids.extensions.db import SQLAlchemyExtension
+from flaskteroids.extensions.routes import RoutesExtension
+from flaskteroids.cli.generators import commands as generate_commands
+from flaskteroids.cli.db import commands as db_commands
+
+
+_logger = logging.getLogger(__name__)
+
+
+def create_app(import_name, config=None):
+    config = _config(config)
+    app = Flask(import_name, template_folder=config['VIEWS']['LOCATION'])
+    app.wsgi_app = ProxyFix(app.wsgi_app)
+
+    _attach_config(app, config)
+    _register_routes(app)
+    _configure_orm(app)
+    _prepare_shell_context(app)
+    _prepare_template_contexts(app)
+    _register_error_handlers(app)
+    _register_cli_commands(app)
+    _setup_csrf(app)
+    _setup_jobs(app)
+    _setup_mailers(app)
+
+    return app
+
+
+def _config(overwrites):
+    cfg = {
+        'SERVER_NAME': 'localhost:5000',
+        'APPLICATION_ROOT': '/',
+        'PREFERRED_URL_SCHEME': 'http',
+        'MODELS': {'LOCATION': 'app.models'},
+        'VIEWS': {'LOCATION': 'app/views/'},
+        'CONTROLLERS': {'LOCATION': 'app.controllers'},
+        'ROUTES': {'LOCATION': 'config.routes'},
+        'DB': {'SQLALCHEMY_URL': 'sqlite:///storage/database.db'},
+        'JOBS': {
+            'LOCATION': 'app.jobs',
+            'CELERY_BROKER_URL': 'sqla+sqlite:///storage/jobs_database.db'
+        },
+        'MAILERS': {
+            'LOCATION': 'app.mailers',
+            'SEND_MAILS': False
+        }
+    }
+    if overwrites:
+        cfg.update(overwrites)
+    if not cfg.get('SECRET_KEY'):
+        cfg['SECRET_KEY'] = secrets.token_hex(64)
+    return cfg
+
+
+def _attach_config(app, config):
+    if config:
+        app.config.update(config)
+
+
+def _register_routes(app):
+    RoutesExtension(app)
+
+
+def _configure_orm(app):
+    SQLAlchemyExtension(app)
+
+
+def _register_error_handlers(app):
+
+    def handle_error(code):
+        def _(e):
+            HttpExceptionClass = default_exceptions.get(code)
+            if HttpExceptionClass:
+                return HttpExceptionClass(description=str(e)).get_response()
+            raise e
+        return _
+
+    app.register_error_handler(model.RecordNotFoundException, handle_error(HTTPStatus.NOT_FOUND))
+
+
+def _register_cli_commands(app):
+    app.cli.add_command(generate_commands.generate, name='generate')
+    app.cli.add_command(generate_commands.generate, name='g')
+    app.cli.add_command(db_commands.init)
+    app.cli.add_command(db_commands.migrate)
+    app.cli.add_command(db_commands.rollback)
+
+
+def _prepare_shell_context(app):
+
+    @app.shell_context_processor
+    def _():
+        _logger.debug('Preparing shell context')
+        db = app.extensions['flaskteroids.db']
+
+        def commit(fn):
+            """This commits immediately changes on models from the shell"""
+            def wrapper(*args, **kwargs):
+                res = fn(*args, **kwargs)
+                session.commit()
+                return res
+            return wrapper
+
+        for model_cls in db.models.values():
+            model_cls.create = commit(model_cls.create)
+            model_cls.update = commit(model_cls.update)
+            model_cls.save = commit(model_cls.save)
+            model_cls.destroy = commit(model_cls.destroy)
+
+        return {
+            **db.models,
+        }
+
+
+def _prepare_template_contexts(app):
+
+    db = app.extensions['flaskteroids.db']
+
+    app.jinja_env.globals['render'] = helpers.render
+    app.jinja_env.globals['button_to'] = helpers.button_to
+    app.jinja_env.globals['link_to'] = helpers.link_to
+    app.jinja_env.globals['form_with'] = helpers.form_with
+    app.jinja_env.globals['csrf_token'] = CSRFToken(app.config.get('SECRET_KEY')).generate
+
+    @app.context_processor
+    def _():
+        return {
+            'flash': flash.messages,
+            **db.models
+        }
+
+
+def _setup_csrf(app):
+    @app.before_request
+    def _():
+        csrft = CSRFToken(app.config.get('SECRET_KEY'))
+        csrft.validate()
+
+
+def _setup_jobs(app):
+    JobsExtension(app)
+
+
+def _setup_mailers(app):
+    MailExtension(app)

flaskteroids/cache/__init__.py

@@ -0,0 +1,27 @@
+from flaskteroids.cache.factory import get_cache
+from flaskteroids.cache.base import MISSING
+
+
+def value(key: str, ttl=None):
+    def wrapper(fn):
+        def decorator(*args, **kwargs):
+            value = fetch(key)
+            if value is not MISSING:
+                return value
+            value = fn(*args, **kwargs)
+            store(key, value, ttl)
+            return value
+        return decorator
+    return wrapper
+
+
+def store(key: str, value, ttl=None):
+    get_cache().store(key, value, ttl)
+
+
+def fetch(key: str):
+    return get_cache().fetch(key)
+
+
+def increment(key: str, ttl=None):
+    return get_cache().increment(key, ttl)

flaskteroids/cache/base.py

@@ -0,0 +1 @@
+MISSING = object()

flaskteroids/cache/factory.py

@@ -0,0 +1,5 @@
+import flaskteroids.cache.inmemory as inmemory
+
+
+def get_cache():
+    return inmemory

flaskteroids/cache/inmemory.py

@@ -0,0 +1,30 @@
+import time
+from flaskteroids.cache.base import MISSING
+
+
+_cache = {}
+
+
+def store(key: str, value, ttl=None):
+    now = time.time()
+    _cache[key] = (value, now + ttl if ttl else None)
+
+
+def fetch(key: str):
+    now = time.time()
+    cached = _cache.get(key)
+
+    if cached:
+        value, timestamp = cached
+        if not timestamp or now <= timestamp:
+            return value
+    return MISSING
+
+
+def increment(key: str, ttl=None):
+    val = fetch(key)
+    if val is MISSING:
+        val = 0
+    val += 1
+    store(key, val, ttl)
+    return val

flaskteroids/cli/artifacts.py

@@ -0,0 +1,55 @@
+import ast
+import os
+import textwrap
+import subprocess
+from pathlib import Path
+
+
+class ArtifactsBuilderException(Exception):
+    pass
+
+
+class ArtifactsBuilder:
+
+    def __init__(self, base_path: str, notify_fn=None):
+        self._base_path = base_path
+        self._notify = notify_fn or (lambda txt: None)
+
+    def _join(self, name):
+        if not name:
+            return Path(self._base_path)
+        return Path(self._base_path, name)
+
+    def dir(self, name=None):
+        os.makedirs(self._join(name), exist_ok=True)
+        self._notify(f"    create  {name}")
+
+    def file(self, name, contents=None):
+        file_path = self._join(name)
+        file_path.parent.mkdir(parents=True, exist_ok=True)
+        file_path.touch(exist_ok=True)
+        if contents:
+            file_path.write_text(self._clean(contents))
+        self._notify(f"    create  {name}")
+
+    def modify_py_file(self, name, contents):
+        with open(self._join(name), "r") as source:
+            tree = ast.parse(source.read())
+        tree = contents().visit(tree)
+        with open(self._join(name), "w") as target:
+            target.write(ast.unparse(tree))
+        self._notify(f"    modify  {name}")
+
+    def run(self, cmd: str):
+        res = subprocess.run(
+            cmd.split(),
+            cwd=self._base_path,
+            capture_output=True,
+            text=True
+        )
+        if res.returncode != 0:
+            raise ArtifactsBuilderException(f'command {cmd} returned {res.returncode}:\n{res.stderr}')
+        self._notify(f"    run  {cmd}")
+
+    def _clean(self, txt: str):
+        return textwrap.dedent(txt).lstrip()

flaskteroids/cli/db/commands.py

@@ -0,0 +1,32 @@
+import click
+from flask.cli import with_appcontext
+from alembic import command
+from flaskteroids.cli.db.config import get_config
+
+
+@click.command('db:init')
+@with_appcontext
+def init():
+    """Init database migrations"""
+    config = get_config()
+    directory = config.get_main_option('script_location')
+    assert directory
+    command.init(config, directory, template='default', package=False)
+
+
+@click.command('db:migrate')
+@with_appcontext
+def migrate():
+    """Apply database migrations"""
+    config = get_config()
+    revision = 'head'
+    command.upgrade(config, revision=revision)
+
+
+@click.command('db:rollback')
+@with_appcontext
+def rollback():
+    """Revert database migrations"""
+    config = get_config()
+    revision = '-1'
+    command.downgrade(config, revision=revision)

flaskteroids/cli/db/config.py

@@ -0,0 +1,21 @@
+import os
+from flask import current_app
+from alembic.config import Config as AlembicConfig
+
+_directory = os.path.join('db', 'migrate')
+
+
+class Config(AlembicConfig):
+
+    def get_template_directory(self):
+        package_dir = os.path.abspath(os.path.dirname(__file__))
+        return os.path.join(package_dir, 'templates')
+
+
+def get_config():
+    config = Config()
+    config.config_file_name = os.path.join(_directory, 'alembic.ini')
+    config.set_main_option('revision_environment', 'true')
+    config.set_main_option('script_location', _directory)
+    config.set_main_option('sqlalchemy.url', current_app.config['DB']['SQLALCHEMY_URL'])
+    return config

flaskteroids/cli/db/templates/default/env.py

@@ -0,0 +1,81 @@
+from logging.config import fileConfig
+
+from sqlalchemy import engine_from_config
+from sqlalchemy import pool
+
+from alembic import context
+
+# this is the Alembic Config object, which provides
+# access to the values within the .ini file in use.
+config = context.config
+
+# Interpret the config file for Python logging.
+# This line sets up loggers basically.
+if config.config_file_name is not None:
+    fileConfig(config.config_file_name)
+
+# add your model's MetaData object here
+# for 'autogenerate' support
+# from myapp import mymodel
+# target_metadata = mymodel.Base.metadata
+target_metadata = None
+
+# other values from the config, defined by the needs of env.py,
+# can be acquired:
+# my_important_option = config.get_main_option("my_important_option")
+# ... etc.
+
+
+def run_migrations_offline() -> None:
+    """Run migrations in 'offline' mode.
+
+    This configures the context with just a URL
+    and not an Engine, though an Engine is acceptable
+    here as well.  By skipping the Engine creation
+    we don't even need a DBAPI to be available.
+
+    Calls to context.execute() here emit the given string to the
+    script output.
+
+    """
+    url = config.get_main_option("sqlalchemy.url")
+    context.configure(
+        url=url,
+        target_metadata=target_metadata,
+        literal_binds=True,
+        dialect_opts={"paramstyle": "named"},
+    )
+
+    with context.begin_transaction():
+        context.run_migrations()
+
+
+def run_migrations_online() -> None:
+    """Run migrations in 'online' mode.
+
+    In this scenario we need to create an Engine
+    and associate a connection with the context.
+
+    """
+    connectable = engine_from_config(
+        config.get_section(config.config_ini_section, {}),
+        prefix="sqlalchemy.",
+        poolclass=pool.NullPool,
+    )
+
+    with connectable.connect() as connection:
+        context.configure(
+            connection=connection,
+            target_metadata=target_metadata,
+            transaction_per_migration=True,
+            render_as_batch=True
+        )
+
+        with context.begin_transaction():
+            context.run_migrations()
+
+
+if context.is_offline_mode():
+    run_migrations_offline()
+else:
+    run_migrations_online()