hyperflask 0.5.2__tar.gz → 0.6.0__tar.gz

{hyperflask-0.5.2 → hyperflask-0.6.0}/PKG-INFO

@@ -1,11 +1,11 @@
 Metadata-Version: 2.4
 Name: hyperflask
-Version: 0.5.2
+Version: 0.6.0
 Summary: Full stack web framework
 Author: Maxime Bouroumeau-Fuseau
 Author-email: Maxime Bouroumeau-Fuseau <maxime.bouroumeau@gmail.com>
 License-Expression: MIT
-Requires-Dist: flask>=3.0.0,<4.0.0
+Requires-Dist: flask>=3.1.0,<4.0.0
 Requires-Dist: flask-assets-pipeline~=0.8
 Requires-Dist: flask-babel-hyper~=5.1
 Requires-Dist: flask-collections~=0.3
@@ -13,7 +13,6 @@ Requires-Dist: flask-configurator~=0.1
 Requires-Dist: flask-debugtoolbar~=0.16
 Requires-Dist: flask-file-routes~=0.3
 Requires-Dist: flask-files~=0.2
-Requires-Dist: flask-geo~=0.1
 Requires-Dist: flask-mailman-templates~=0.1
 Requires-Dist: flask-mercure-sse~=0.4
 Requires-Dist: flask-sqlorm~=0.3
@@ -43,7 +42,7 @@ Description-Content-Type: text/markdown
 
 **Full stack Python web framework to build websites and web apps with as little boilerplate as possible**
 
-[hyperflask.dev](https://hyperflask.dev) • [Get started](https://hyperflask.dev/getting-started) • [Docs](https://hyperflask.dev/guides) • [Example apps](https://github.com/hyperflask/examples)
+[hyperflask.dev](https://hyperflask.dev) • [Get started](https://hyperflask.dev/getting-started) • [Docs](https://hyperflask.dev/guides) • [Example app](https://github.com/hyperflask/getting-started)
 
 </div>
 
@@ -74,11 +73,10 @@ Features and technologies:
  - Dev environment based on [Development Containers](https://containers.dev/)
  - Optimized for VScode with breakpoint debugging for frontend and backend
  - [Mailpit](https://github.com/axllent/mailpit) for email testing
- - Deployments using [docker-web-deploy](https://github.com/hyperflask/docker-web-deploy)
 
 ## Project status
 
-**Hyperflask is being actively developed and is not yet ready to be used.**
+**Hyperflask is in BETA and can start to be used for non-critical production apps**
 
 Checkout the list of all the projects developed as part of the Hyperflask stack and their current development status on the [Hyperflask Github organization homepage](https://github.com/hyperflask).
 
@@ -116,5 +114,6 @@ A good part of these extensions is developed as part of the Hyperflask project.
 1. Create your project directory: `mkdir example-project && cd example-project`
 2. Create and activate a virtualenv: `python -m venv .venv && source .venv/bin/activate`
 3. `pip install hyperflask`
-4. Run `hyperflask init .`
-5. Start a development server using `hyperflask dev`
+5. Run `npm install esbuild tailwindcss @tailwindcss/cli htmx.org htmx-ext-sse bootstrap-icons daisyui`
+4. Run `mkdir pages && echo "Hello world" > pages/index.jpy`
+6. Start a development server using `hyperflask dev`

{hyperflask-0.5.2 → hyperflask-0.6.0}/README.md

@@ -4,7 +4,7 @@
 
 **Full stack Python web framework to build websites and web apps with as little boilerplate as possible**
 
-[hyperflask.dev](https://hyperflask.dev) • [Get started](https://hyperflask.dev/getting-started) • [Docs](https://hyperflask.dev/guides) • [Example apps](https://github.com/hyperflask/examples)
+[hyperflask.dev](https://hyperflask.dev) • [Get started](https://hyperflask.dev/getting-started) • [Docs](https://hyperflask.dev/guides) • [Example app](https://github.com/hyperflask/getting-started)
 
 </div>
 
@@ -35,11 +35,10 @@ Features and technologies:
  - Dev environment based on [Development Containers](https://containers.dev/)
  - Optimized for VScode with breakpoint debugging for frontend and backend
  - [Mailpit](https://github.com/axllent/mailpit) for email testing
- - Deployments using [docker-web-deploy](https://github.com/hyperflask/docker-web-deploy)
 
 ## Project status
 
-**Hyperflask is being actively developed and is not yet ready to be used.**
+**Hyperflask is in BETA and can start to be used for non-critical production apps**
 
 Checkout the list of all the projects developed as part of the Hyperflask stack and their current development status on the [Hyperflask Github organization homepage](https://github.com/hyperflask).
 
@@ -77,5 +76,6 @@ A good part of these extensions is developed as part of the Hyperflask project.
 1. Create your project directory: `mkdir example-project && cd example-project`
 2. Create and activate a virtualenv: `python -m venv .venv && source .venv/bin/activate`
 3. `pip install hyperflask`
-4. Run `hyperflask init .`
-5. Start a development server using `hyperflask dev`
+5. Run `npm install esbuild tailwindcss @tailwindcss/cli htmx.org htmx-ext-sse bootstrap-icons daisyui`
+4. Run `mkdir pages && echo "Hello world" > pages/index.jpy`
+6. Start a development server using `hyperflask dev`

{hyperflask-0.5.2 → hyperflask-0.6.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "hyperflask"
-version = "0.5.2"
+version = "0.6.0"
 description = "Full stack web framework"
 authors = [
     {"name" = "Maxime Bouroumeau-Fuseau", email = "maxime.bouroumeau@gmail.com"}
@@ -9,7 +9,7 @@ readme = "README.md"
 license = "MIT"
 requires-python = ">=3.10"
 dependencies = [
-    "flask>=3.0.0,<4.0.0",
+    "flask>=3.1.0,<4.0.0",
     "flask-assets-pipeline ~=0.8",
     "flask-babel-hyper ~=5.1",
     "flask-collections ~=0.3",
@@ -17,7 +17,6 @@ dependencies = [
     "flask-debugtoolbar ~=0.16",
     "flask-file-routes ~=0.3",
     "flask-files ~=0.2",
-    "flask-geo ~=0.1",
     "flask-mailman-templates ~=0.1",
     "flask-mercure-sse ~=0.4",
     #"flask-observability ~=0.1"
@@ -49,6 +48,9 @@ Repository = "https://github.com/hyperflask/hyperflask"
 [project.scripts]
 hyperflask = "hyperflask.cli:main"
 
+[project.entry-points."flask_collections"]
+model = "hyperflask.model:ModelCollection"
+
 [dependency-groups]
 dev = [
     "pytest>=8.4.1",

{hyperflask-0.5.2 → hyperflask-0.6.0}/src/hyperflask/__init__.py

@@ -3,6 +3,8 @@ from .app import Hyperflask
 from .utils.htmx import htmx_redirect, htmx_oob
 from .utils.freezer import StaticMode, static, dynamic
 from .security import csp_nonce
+from .actors import actor, ActorGroup
+from .models import Model
 
 # useful exports from hyperflask managed extensions
 from flask_babel import gettext, _, pgettext, _p, ngettext, _n, npgettext, _np, lazy_gettext, _lazy
@@ -18,3 +20,4 @@ from htmx_flask import request, make_response
 from slugify import slugify
 from blinker import signal
 from periodiq import cron
+from sqlorm import transaction

hyperflask-0.6.0/src/hyperflask/actors.py

@@ -0,0 +1,128 @@
+from threading import local
+import typing as t
+import importlib
+from datetime import timedelta
+from dramatiq import Middleware, actor as register_actor, Message
+from flask import has_app_context, current_app
+from sqlorm.helpers import after_commit as sqlorm_after_commit
+
+
+DRAMATIQ_BROKERS = {
+    "amqp": "dramatiq.brokers.rabbitmq:RabbitmqBroker",
+    "redis": "dramatiq.brokers.redis:RedisBroker",
+    "sqlite": "dramatiq_sqlite:SQLiteBroker",
+}
+
+
+def discover_broker(broker_cls=None, broker_url=None):
+    if not broker_url and broker_cls and "://" in broker_cls:
+        broker_url = broker_cls
+        broker_cls = None
+    if not broker_cls and broker_url:
+        if "://" not in broker_url:
+            broker_name = "sqlite"
+        else:
+            broker_name, broker_url = broker_url.split("://", 1)
+        if broker_name not in DRAMATIQ_BROKERS:
+            raise ValueError(f"Unknown dramatiq broker '{broker_name}'")
+        broker_cls = DRAMATIQ_BROKERS[broker_name]
+    if isinstance(broker_cls, str):
+        module_name, cls_name = broker_cls.split(":")
+        module = importlib.import_module(module_name)
+        broker_cls = getattr(module, cls_name)
+    return broker_cls, broker_url
+
+
+class actor:
+    @classmethod
+    def bind(cls, broker):
+        return type('bound_actor', (cls,), {'__broker__': broker})
+
+    def __init__(self, *args, **kwargs):
+        self.actor_args = (args, kwargs)
+        self.fn = None
+        self.actor = None
+
+    def __call__(self, *args, **kwargs):
+        if not self.fn:
+            self.fn = args[0]
+            if getattr(self, '__broker__', None):
+                self.register(self.__broker__)
+            elif has_app_context() and getattr(current_app, 'dramatiq_broker', None):
+                self.register(current_app.dramatiq_broker)
+            return self
+        return self.fn(*args, **kwargs)
+
+    def register(self, broker):
+        self.actor = register_actor(broker=broker, *self.actor_args[0], **self.actor_args[1])(self.fn)
+
+    def __getattr__(self, name):
+        if self.actor:
+            return getattr(self.actor, name)
+        raise AttributeError(name)
+
+    def send(self, *args, **kwargs):
+        return self.send_with_options(args=args, kwargs=kwargs)
+
+    def send_with_options(
+        self,
+        *,
+        args: tuple = (),
+        kwargs: t.Optional[dict[str, t.Any]] = None,
+        delay: t.Optional[timedelta | int] = None,
+        after_commit: bool = True,
+        **options,
+    ) -> Message:
+        if not self.actor:
+            raise RuntimeError("No broker defined for Dramatiq actors.")
+
+        if isinstance(delay, timedelta):
+            delay = int(delay.total_seconds() * 1000)
+
+        message = self.actor.message_with_options(args=args, kwargs=kwargs, **options)
+
+        if after_commit:
+            sqlorm_after_commit(lambda: self.actor.broker.enqueue(message, delay=delay))
+            return message
+
+        return self.actor.broker.enqueue(message, delay=delay)
+
+
+class ActorGroup(list):
+    def actor(self, *args, **kwargs):
+        def decorator(fn):
+            a = actor(*args, **kwargs)(fn)
+            self.append(a)
+            return a
+        return decorator
+
+    def register(self, broker):
+        for a in self:
+            a.register(broker)
+
+
+class AppContextMiddleware(Middleware):
+    # Setup Flask app for actor. Borrowed from
+    # https://github.com/Bogdanp/flask_dramatiq_example.
+
+    state = local()
+
+    def __init__(self, app):
+        self.app = app
+
+    def before_process_message(self, broker, message):
+        context = self.app.app_context()
+        context.push()
+
+        self.state.context = context
+
+    def after_process_message(
+            self, broker, message, *, result=None, exception=None):
+        try:
+            context = self.state.context
+            context.pop(exception)
+            del self.state.context
+        except AttributeError:
+            pass
+
+    after_skip_message = after_process_message

{hyperflask-0.5.2 → hyperflask-0.6.0}/src/hyperflask/app.py

@@ -1,5 +1,6 @@
 # flask
-from flask import Flask, has_request_context, request
+from flask import Flask, has_request_context, request, current_app
+from flask.globals import _cv_app
 from jinja2 import ChoiceLoader, FileSystemLoader, PrefixLoader, TemplateNotFound
 from werkzeug.middleware.proxy_fix import ProxyFix
 # hyperflask extensions
@@ -11,7 +12,6 @@ from flask_collections import Collections
 from flask_file_routes import FileRoutes, ModuleView, page
 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
@@ -33,13 +33,14 @@ from .utils.metadata import metadata_tags
 from .utils.freezer import StaticMode, Freezer, freezer_url_generator
 from .utils.image import image_tag
 from .components import register_components
-from .model import Model, File as SQLFileType, UndefinedDatabase
-from .actors import AppContextMiddleware, discover_broker, make_actor_decorator
+from .models import Model, File as SQLFileType, UndefinedDatabase
+from .actors import AppContextMiddleware, discover_broker, actor
 from .security import respond_with_security_headers, csp_nonce
 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 import transaction
 from sqlorm.sql_template import SQLTemplate
 from periodiq import PeriodiqMiddleware
 import os
@@ -77,7 +78,6 @@ class Hyperflask(Flask):
             "SESSION_COOKIE_SAMESITE": "Lax",
             "SQLORM_URI": database_uri,
             # Hyperflask specific
-            "URL_FOR_SERVER_NAME": None,
             "LAYOUT": "layouts/default.html",
             "ALPINE": False,
             "STATIC_MODE": static_mode,
@@ -151,7 +151,7 @@ class Hyperflask(Flask):
             PrefixLoader({"ui": FileSystemLoader(os.path.join(os.path.dirname(__file__), "ui"))})
         ])
 
-        DebugToolbarExtension(self)
+        HyperDebugToolbarExtension(self)
         self.freezer = Freezer(self, with_no_argument_rules=False, log_url_for=self.config.get('FREEZER_LOG_URL_FOR', False))
         self.freezer.register_generator(lambda: freezer_url_generator(self))
         self.csrf = CSRFProtect(self)
@@ -161,7 +161,6 @@ class Hyperflask(Flask):
         SuperMacros(self)
         self.components = self.macros # alias
         Babel(self, extract_locale_from_request="locale")
-        Geolocation(self)
         Files(self)
         MailTemplates(self, template_folder=emails_folder)
         file_routes = FileRoutes(self, pages_folder=pages_folder, module_view_class=HyperModuleView)
@@ -235,7 +234,9 @@ class Hyperflask(Flask):
             self.dramatiq_broker = broker_cls(url=broker_url)
             self.dramatiq_broker.add_middleware(AppContextMiddleware(self))
             self.dramatiq_broker.add_middleware(PeriodiqMiddleware())
-        self.actor = make_actor_decorator(self)
+            self.actor = actor.bind(self.dramatiq_broker)
+        else:
+            self.actor = actor
 
         Suspense(self, nonce_getter="csp_nonce()")
 
@@ -281,32 +282,39 @@ class Hyperflask(Flask):
         scheme = self.config.get('PREFERRED_URL_SCHEME', 'http')
         if self.config.get('SERVER_NAME'):
             return f"{scheme}://{self.config['SERVER_NAME']}"
-        if self.config['URL_FOR_SERVER_NAME']:
-            return f"{scheme}://{self.config['URL_FOR_SERVER_NAME']}"
         if has_request_context():
             return request.host_url
-        raise RuntimeError("No request context and no SERVER_NAME or URL_FOR_SERVER_NAME configured, cannot determine base_url")
+        raise RuntimeError("No request context and no SERVER_NAME configured, cannot determine base_url")
 
     def url_for(self, *args, **kwargs):
         _external = kwargs.get("_external", False)
-        _scheme = kwargs.get("_scheme", None)
-        if _external and self.config['URL_FOR_SERVER_NAME']:
-            # we handle the host and scheme ourselves
-            kwargs['_external'] = False
-            kwargs.pop('_scheme', None)
-        else:
-            _external = False
-        url = super().url_for(*args, **kwargs)
-        if not _external:
+        if not has_request_context() and not _external and not self.config.get('SERVER_NAME'):
+            self.config['SERVER_NAME'] = 'http://localhost:5000'
+            app_ctx = _cv_app.get(None)
+            if app_ctx is not None:
+                prev_url_adapter = app_ctx.url_adapter
+                app_ctx.url_adapter = self.create_url_adapter(None)
+            url = super().url_for(*args, **kwargs)
+            if app_ctx is not None:
+                app_ctx.url_adapter = prev_url_adapter
+            url = url[:len(self.config['SERVER_NAME']):]
+            self.config['SERVER_NAME'] = None
             return url
-        if not _scheme:
-            _scheme = self.config.get('PREFERRED_URL_SCHEME', 'http')
-        url = f"{_scheme}://{self.config['URL_FOR_SERVER_NAME']}{url}"
-        return url
+        return super().url_for(*args, **kwargs)
 
 
 class HyperModuleView(ModuleView):
-    module_globals = dict(ModuleView.module_globals, asset_url=asset_url, static_url=static_url)
+    module_globals = dict(ModuleView.module_globals,
+                          asset_url=asset_url,
+                          static_url=static_url,
+                          transaction=transaction)
 
     def _render_template(self):
         return render_template(page.template)
+
+
+class HyperDebugToolbarExtension(DebugToolbarExtension):
+    def _show_toolbar(self):
+        if current_app.config.get("DEBUG_TB_ENABLED", True) is False:
+            return False
+        return super()._show_toolbar()

hyperflask-0.6.0/src/hyperflask/cli/__init__.py

@@ -0,0 +1,135 @@
+import os
+import json
+import click
+from flask import current_app
+from flask.cli import FlaskGroup, shell_command, routes_command, ScriptInfo, NoAppException
+from flask_assets_pipeline import cli as assets_cli
+from ..factory import create_app
+from ..security import generate_csp_policy
+from ..utils.freezer import StaticMode
+from .runner import serve_command, run_command, dev_command
+from .worker import worker_command, scheduler_command
+from .scaffold import gen
+
+
+def _create_app():
+    try:
+        if os.environ.get("FLASK_APP") == "0":
+            raise NoAppException("")
+        info = ScriptInfo(os.environ.get("FLASK_APP"))
+        return info.load_app()
+    except NoAppException:
+        return create_app(os.environ.get("FLASK_ROOT"))
+
+
+cli = FlaskGroup(name='kantree', help='Kantree', add_default_commands=False, create_app=_create_app)
+cli.add_command(shell_command)
+cli.add_command(routes_command)
+cli.add_command(serve_command)
+cli.add_command(run_command)
+cli.add_command(dev_command)
+cli.add_command(worker_command)
+cli.add_command(scheduler_command)
+cli.add_command(gen)
+
+
+@cli.command("build")
+@click.pass_context
+def build_command(ctx):
+    ctx.invoke(assets_cli.build)
+    if StaticMode(current_app.config['STATIC_MODE']) != StaticMode.DYNAMIC:
+        current_app.freezer.freeze()
+
+
+@cli.command("csp-header")
+def csp_header_command():
+    click.echo(generate_csp_policy())
+
+
+@cli.command("encode-session-cookie")
+@click.argument("data")
+def encode_session_cookie_command(data):
+    """Encode a session cookie value from JSON data"""
+    serializer = current_app.session_interface.get_signing_serializer(current_app)
+    value = serializer.dumps(json.loads(data))
+    click.echo(value)
+
+
+@cli.command("decode-session-cookie")
+@click.argument("cookie", required=False)
+@click.option("--cookie-file", "-f", type=click.Path(exists=True), help="Path to a file containing a list of cookies (from test-request command)")
+def decode_session_cookie_command(cookie, cookie_file):
+    """Decode a session cookie value to JSON data"""
+    if not cookie and cookie_file:
+        with open(cookie_file, "r") as f:
+            for cookie_data in f.readlines():
+                key, value = cookie_data.split(";", 1)[0].split("=", 1)
+                if key.strip() == current_app.config["SESSION_COOKIE_NAME"]:
+                    cookie = value.strip()
+                    break
+    elif not cookie:
+        click.echo("Either COOKIE argument or --cookie-file option must be provided", err=True)
+        return
+    try:
+        serializer = current_app.session_interface.get_signing_serializer(current_app)
+        data = serializer.loads(cookie)
+        click.echo(json.dumps(data, indent=2))
+    except Exception as e:
+        click.echo("Cannot decode cookie value", err=True)
+        return
+
+
+@cli.command("test-request")
+@click.argument("path")
+@click.option("--method", "-m", default="GET", help="HTTP method to use")
+@click.option("--data", "-d", default=None, help="Data to send with the request")
+@click.option("--header", "-h", multiple=True, help="Headers to include in the request")
+@click.option("--follow-redirects/--no-follow-redirects", default=True, help="Whether to follow redirects")
+@click.option("--session", "-s", help="JSON data that will be used to populate the session cookie")
+@click.option("--cookie", "-c", multiple=True, help="Cookies to include in the request")
+@click.option("--cookie-file", "-f", type=click.Path(), help="Path to read and write cookies from, helpful for preserving cookies between requests")
+@click.pass_context
+def test_request_command(ctx, path, method, data, header, follow_redirects, cookie, session, cookie_file):
+    """Simulate a request to the application and display the response. The path can include query parameters.
+    """
+    current_app.config["DEBUG_TB_ENABLED"] = False
+    client = current_app.test_client()
+    headers = []
+    cookies = {}
+    for header_ in header:
+        key, value = header_.split(":", 1)
+        headers.append((key.strip(), value.strip()))
+    if cookie_file and os.path.exists(cookie_file):
+        with open(cookie_file, "r") as f:
+            for cookie_data in f.readlines():
+                key, value = cookie_data.split(";", 1)[0].split("=", 1)
+                cookies[key.strip()] = value.strip()
+                client.set_cookie(key=key.strip(), value=value.strip())
+    if cookie:
+        for cookie_ in cookie:
+            key, value = cookie_.split("=", 1)
+            cookies[key.strip()] = value.strip()
+            client.set_cookie(key=key.strip(), value=value.strip())
+    if session:
+        serializer = current_app.session_interface.get_signing_serializer(current_app)
+        session_cookie = serializer.dumps(json.loads(session))
+        client.set_cookie(key=current_app.config["SESSION_COOKIE_NAME"], value=session_cookie)
+
+    resp = client.open(path=path, method=method, data=data, headers=headers, follow_redirects=follow_redirects)
+
+    click.echo(f"HTTP/1.1 {resp.status}")
+    for key, value in resp.headers.items():
+        click.echo(f"{key}: {value}")
+        if key.lower() == "set-cookie":
+            name, value = value.split(";", 1)[0].split("=", 1)
+            cookies[name.strip()] = value.strip()
+    click.echo("")
+    click.echo(resp.get_data(as_text=True))
+    if cookie_file and cookies:
+        with open(cookie_file, "w") as f:
+            for name, value in cookies.items():
+                f.write(f"{name}={value}\n")
+
+
+def main():
+    cli.main()

{hyperflask-0.5.2 → hyperflask-0.6.0}/src/hyperflask/cli/runner.py

@@ -16,16 +16,17 @@ from . import reloader # import hacky patch of werkzeug reloader
 
 
 @click.command("serve")
+@click.option("--gunicorn/--no-gunicorn", default=True, is_flag=True, help="Use Gunicorn to serve the app.")
 @click.option('--gunicorn-config')
 @click.option("--init-db", is_flag=True)
 @pass_script_info
 @click.pass_context
-def serve_command(ctx, info, host, port, gunicorn_config, init_db, **run_kwargs):
+def serve_command(ctx, info, host, port, gunicorn, gunicorn_config, init_db, **run_kwargs):
     if init_db:
         print("Initializing database...")
         Popen([sys.argv[0], "db", "init"]).wait()
 
-    if os.environ.get("FLASK_DEBUG") == "1":
+    if not gunicorn or os.environ.get("FLASK_DEBUG") == "1":
         ctx.invoke(flask_run_command, host=host, port=port, **run_kwargs)
         return
 
@@ -45,12 +46,13 @@ serve_command.params = flask_run_command.params + serve_command.params
 @click.argument('processes', nargs=-1)
 @click.option("--host", "-h", default="127.0.0.1", help="The interface to bind to.")
 @click.option("--port", "-p", default=5000, help="The port to bind to.")
-@click.option('--concurrency')
-@click.option("--extend-procfile", is_flag=True)
-@click.option("--init-db/--no-init-db", is_flag=True, default=None)
-@click.option('--gunicorn-config')
-@click.option("--dev", is_flag=True)
-def run_command(processes, host, port, concurrency, extend_procfile, init_db, gunicorn_config, dev):
+@click.option('--concurrency', help="Number of concurrent processes to run.")
+@click.option("--extend-procfile", is_flag=True, help="Extend an existing Procfile instead of using it")
+@click.option("--init-db/--no-init-db", is_flag=True, default=None, help="Initialize the database before starting processes.")
+@click.option('--gunicorn-config', help="A gunicorn configuration value for the web process in production (in the form key=value)")
+@click.option("--logfile", help="File to log output of all processes to instead of stdout.")
+@click.option("--dev", is_flag=True, help="Run in development mode with debug enabled.")
+def run_command(processes, host, port, concurrency, extend_procfile, init_db, gunicorn_config, logfile, dev):
     if dev:
         os.environ["FLASK_DEBUG"] = "1"
 
@@ -58,57 +60,36 @@ def run_command(processes, host, port, concurrency, extend_procfile, init_db, gu
         print("Initializing database...")
         Popen([sys.argv[0], "db", "init"]).wait()
 
-    _processes = {}
-    procfile = None
     config = load_config()
 
     if not dev and not config.get('SECRET_KEY'):
         print("Critical: No SECRET_KEY set, cannot run in production mode.")
         sys.exit(1)
 
+    _processes = get_default_processes(dev=dev, gunicorn_config=gunicorn_config, host=host)
+
     for filename in [f"Procfile.{config['ENV']}", "Procfile"]:
         if os.path.exists(filename):
             with open(filename) as f:
                 procfile = parse_procfile(f.read()).processes
+            if extend_procfile:
+                _processes.update(procfile)
+            else:
+                _processes = procfile
             break
 
-    _processes = {
-        "web": [sys.argv[0], "serve", "--host", host, "--port", "$PORT"],
-        "worker": [sys.argv[0], "worker"],
-        "scheduler": [sys.argv[0], "scheduler"]
-    }
-    if gunicorn_config:
-        _processes["web"].extend(["--gunicorn-config", gunicorn_config])
+    processes = {name: cmd for name, cmd in _processes.items() if not processes or name in processes}
+    env = {}
     if dev:
-        _processes["assets"] = [sys.argv[0], "assets", "dev"]
-        _processes["worker"].extend(["-p", "1", "-t", "1"])
+        env = {"FLASK_DEBUG": "1"}
     else:
-        _processes["mercurehub"] = [sys.executable, "-m", "flask_mercure_sse.server", "--port", "$PORT"]
-
-    if procfile and extend_procfile:
-        _processes.update(procfile)
-    elif procfile:
-        _processes = procfile
-
-    processes = {name: " ".join(_processes[name]) if isinstance(_processes[name], list) else _processes[name]
-                 for name in _processes if not processes or name in processes}
-    env = {}
-    if not dev:
         env = {
             "MERCURE_SUBSCRIBER_SECRET_KEY": config.get("MERCURE_SUBSCRIBER_SECRET_KEY", config['SECRET_KEY']),
             "MERCURE_PUBLISHER_SECRET_KEY": config.get("MERCURE_PUBLISHER_SECRET_KEY", config['SECRET_KEY']),
         }
 
-    manager = ProcessManager(Printer(sys.stdout, colour=True))
-    for p in environ.expand_processes(processes,
-                                      concurrency=_parse_concurrency(concurrency),
-                                      port=port):
-        e = os.environ.copy()
-        e.update(env)
-        e.update(p.env)
-        manager.add_process(p.name, p.cmd, quiet=p.quiet, env=e)
-
     print("Starting Hyperflask processes...")
+    manager = create_process_manager(processes, port=port, concurrency=concurrency, env=env, logfile=logfile)
     manager.loop()
     sys.exit(manager.returncode)
 
@@ -125,6 +106,43 @@ def dev_command(ctx, **kwargs):
 dev_command.params = list(run_command.params)
 
 
+def get_default_processes(dev=False, gunicorn_config=None, host="127.0.0.1"):
+    processes = {
+        "web": [sys.argv[0], "serve", "--host", host, "--port", "$PORT"],
+        "worker": [sys.argv[0], "worker"],
+        "scheduler": [sys.argv[0], "scheduler"]
+    }
+    if gunicorn_config:
+        processes["web"].extend(["--gunicorn-config", gunicorn_config])
+    if dev:
+        processes["assets"] = [sys.argv[0], "assets", "dev"]
+        processes["worker"].extend(["-p", "1", "-t", "1"])
+    else:
+        processes["mercurehub"] = [sys.executable, "-m", "flask_mercure_sse.server", "--port", "$PORT"]
+    return processes
+
+
+def create_process_manager(processes, port=5000, concurrency=None, env=None, logfile=None):
+    processes = {name: " ".join(cmd) if isinstance(cmd, list) else cmd for name, cmd in processes.items()}
+    manager = ProcessManager(Printer(sys.stdout, colour=True))
+    if not env:
+        env = {}
+    env["BASE_PORT"] = str(port)
+    for p in environ.expand_processes(processes,
+                                      concurrency=_parse_concurrency(concurrency),
+                                      port=port):
+        e = os.environ.copy()
+        e.update(env)
+        e.update(p.env)
+        manager.add_process(p.name, p.cmd, quiet=p.quiet, env=e)
+
+    if logfile:
+        log_file = open(logfile, "a")
+        manager.printer.output = log_file
+
+    return manager
+
+
 class ProcessManager(BaseProcessManager):
     # This override prevents the manager to stop if the worker and scheduler exit because dramatiq is unused
     def _any_stopped(self):