Pyjoyment 0.1.0__py3-none-any.whl

Pyjoyment/__init__.py

@@ -0,0 +1,1083 @@
+"""
+Pyjoyment - Real-time web framework
+===================================
+::
+
+    # Application
+    import Pyjoyment
+
+    class MyApp(Pyjoyment.object):
+
+        # Route
+        def startup(self):
+            self.get('/hello').to('foo#hello')
+
+    # Controller
+    import Pyjoyment.Controller
+
+    class MyApp_Controller_Foo(Pyjoyment.Controller.object):
+
+        # Action
+        def hello(self):
+            self.render(text='Hello World!')
+
+An amazing real-time web framework built on top of the powerful :mod:`Pyjo`
+web development toolkit, ported from `Mojolicious <https://mojolicious.org>`_.
+With support for RESTful routes, plugins, content negotiation, session
+management, static file server, first class Unicode support and much more for
+you to discover.
+
+Hooks
+-----
+
+:mod:`Pyjoyment` will emit the following hooks in the listed order.
+
+before_command
+    Emitted right before the application runs a command through the command
+    line interface. ::
+
+        @app.hook('before_command')
+        def before_command(command, args): ...
+
+    Useful for reconfiguring the application before running a command or to
+    modify the behavior of a command. (Passed the command object and the list
+    of the command arguments)
+
+before_server_start
+    Emitted right before the application server is started, for web servers
+    that support it, which includes all the built-in ones. ::
+
+        @app.hook('before_server_start')
+        def before_server_start(server, app): ...
+
+    Useful for reconfiguring application servers dynamically or collecting
+    server diagnostics information. (Passed the server and application
+    objects)
+
+after_build_tx
+    Emitted right after the transaction is built and before the HTTP request
+    gets parsed. ::
+
+        @app.hook('after_build_tx')
+        def after_build_tx(tx, app): ...
+
+    This is a very powerful hook and should not be used lightly, it makes some
+    rather advanced features such as upload progress bars possible. Note that
+    this hook will not work for embedded applications, because only the host
+    application gets to build transactions. (Passed the transaction and
+    application objects)
+
+around_dispatch
+    Emitted right after a new request has been received and wraps around the
+    whole dispatch process, so you have to manually forward to the next hook
+    if you want to continue the chain. Default exception handling with the
+    helper ``reply.exception`` of :mod:`Pyjoyment.Plugin.DefaultHelpers` is
+    the first hook in the chain and a call to :meth:`Pyjoyment_App.dispatch`
+    the last, yours will be in between. ::
+
+        @app.hook('around_dispatch')
+        def around_dispatch(next, c):
+            ...
+            next()
+            ...
+
+    This is a very powerful hook and should not be used lightly, it allows
+    you, for example, to customize application-wide exception handling,
+    consider it the sledgehammer in your toolbox. (Passed a callback leading
+    to the next hook and the default controller object)
+
+before_dispatch
+    Emitted right before the static file server and router start their work. ::
+
+        @app.hook('before_dispatch')
+        def before_dispatch(c): ...
+
+    Very useful for rewriting incoming requests and other preprocessing
+    tasks. (Passed the default controller object)
+
+after_static
+    Emitted after a static file response has been generated by the static
+    file server. ::
+
+        @app.hook('after_static')
+        def after_static(c): ...
+
+    Mostly used for post-processing static file responses. (Passed the
+    default controller object)
+
+before_routes
+    Emitted after the static file server determined if a static file should
+    be served and before the router starts its work. ::
+
+        @app.hook('before_routes')
+        def before_routes(c): ...
+
+    Mostly used for custom dispatchers and collecting metrics. (Passed the
+    default controller object)
+
+around_action
+    Emitted right before an action gets executed and wraps around it, so you
+    have to manually forward to the next hook if you want to continue the
+    chain. Default action dispatching is the last hook in the chain, yours
+    will run before it. ::
+
+        @app.hook('around_action')
+        def around_action(next, c, action, last):
+            ...
+            return next()
+
+    This is a very powerful hook and should not be used lightly, it allows you
+    for example to pass additional arguments to actions or handle return
+    values differently. Note that this hook can trigger more than once for the
+    same request if there are nested routes. (Passed a callback leading to the
+    next hook, the current controller object, the action callback and a flag
+    indicating if this action is an endpoint)
+
+before_render
+    Emitted before content is generated by the renderer. Note that this hook
+    can trigger out of order due to its dynamic nature, and with embedded
+    applications will only work for the application that is rendering. ::
+
+        @app.hook('before_render')
+        def before_render(c, args): ...
+
+    Mostly used for pre-processing arguments passed to the renderer. (Passed
+    the current controller object and the render arguments)
+
+after_render
+    Emitted after content has been generated by the renderer that will be
+    assigned to the response. Note that this hook can trigger out of order due
+    to its dynamic nature, and with embedded applications will only work for
+    the application that is rendering. ::
+
+        @app.hook('after_render')
+        def after_render(c, output, format): ...
+
+    Mostly used for post-processing dynamically generated content. (Passed
+    the current controller object, a file object with the content and the
+    format)
+
+after_dispatch
+    Emitted in reverse order after a response has been generated. Note that
+    this hook can trigger out of order due to its dynamic nature, and with
+    embedded applications will only work for the application that is
+    generating the response. ::
+
+        @app.hook('after_dispatch')
+        def after_dispatch(c): ...
+
+    Useful for rewriting outgoing responses and other post-processing tasks.
+    (Passed the current controller object)
+
+after_server_stop
+    Emitted right after the application server has stopped gracefully, in
+    each process and thread that has run the application, for web servers
+    that support it, which includes all the built-in ones but
+    :mod:`Pyjo.Server.WSGI` and :mod:`Pyjo.Server.Lambda`, which do not know
+    when they stop. The event loop no longer runs, and the server runs it
+    until a :mod:`Pyjo.Promise` that the hook returns is settled. ::
+
+        @app.hook('after_server_stop')
+        def after_server_stop(server, app): ...
+
+    Useful for cleaning up what the application has started for the
+    server, as the connections of a pool. (Passed the server and application
+    objects)
+
+Helpers
+-------
+
+In addition to the attributes and methods below you can also call helpers on
+:mod:`Pyjoyment` objects. This includes all helpers from
+:mod:`Pyjoyment.Plugin.DefaultHelpers` and :mod:`Pyjoyment.Plugin.TagHelpers`.
+Note that application helpers are always called with a new default controller
+object, so they can't depend on or change controller state, which includes
+request, response and stash. ::
+
+    # Call helper
+    print(app.dumper({'foo': 'bar'}))
+
+    # Longer version
+    print(app.build_controller().helpers.dumper({'foo': 'bar'}))
+
+See also
+--------
+
+:mod:`Pyjo`, https://mojolicious.org.
+
+Ported from `Mojolicious <https://github.com/mojolicious/mojo/blob/v9.53/lib/Mojolicious.pm>`_ of Mojolicious 9.53.
+"""
+
+# Not in Mojolicious: a namespace that other distributions can add modules to, open before the package imports its
+# subpackages, as Pyjoyment.Plugin and Pyjoyment.Command, which are namespaces that find their parts in it
+from pkgutil import extend_path
+
+
+__path__ = extend_path(__path__, __name__)
+
+import Pyjo.App
+import Pyjo.Loader
+import Pyjo.Log
+import Pyjo.Promise
+import Pyjo.Server
+import Pyjo.Transaction.HTTP
+import Pyjo.Util
+import Pyjoyment.Commands
+import Pyjoyment.Controller
+import Pyjoyment.Plugins
+import Pyjoyment.Renderer
+import Pyjoyment.Routes
+import Pyjoyment.Routes.Pattern
+import Pyjoyment.Routes.Route
+import Pyjoyment.Sessions
+import Pyjoyment.Static
+import Pyjoyment.Types
+import Pyjoyment.Validator
+
+import functools
+import inspect
+import os
+import sys
+
+from collections.abc import Callable
+from typing import TYPE_CHECKING, Any, Self, cast, overload
+
+
+if TYPE_CHECKING:
+    import Pyjoyment.Plugin.DefaultHelpers
+    import Pyjoyment.Plugin.TagHelpers
+
+    # Not in Mojolicious: the types of the helpers of the default plugins, which type checkers take from here, while
+    # __getattr__ finds the helpers in the renderer at run time
+    class _Base(Pyjo.App.object, Pyjoyment.Plugin.DefaultHelpers.Helpers, Pyjoyment.Plugin.TagHelpers.Helpers): ...
+
+else:
+    _Base = Pyjo.App.object
+
+
+class Pyjoyment_App(_Base):
+    """
+    :mod:`Pyjoyment` inherits all attributes and methods from :mod:`Pyjo.App`
+    and implements the following new ones.
+    """
+
+    _stashes = ('config', 'defaults')
+
+    # Left out from Mojolicious: $CODENAME and $VERSION, as the version of the distribution is in its metadata
+
+    def __init__(self, attrs: dict[str, Any] | None = None, /, **kwargs: Any) -> None:
+        """::
+
+            app = Pyjoyment.new()
+            app = Pyjoyment.new(moniker='foo_bar')
+            app = Pyjoyment.new({'moniker': 'foo_bar'})
+
+        Construct a new :mod:`Pyjoyment` application and call
+        :meth:`startup`. Will automatically detect your home directory. Also
+        sets up the renderer, a default set of plugins and an
+        ``around_dispatch`` hook with the default exception handling.
+        """
+        self._commands: Pyjoyment.Commands.object | None = None
+
+        self.controller_class: type[Pyjoyment.Controller.object] | str = Pyjoyment.Controller.object
+        """::
+
+            cls = app.controller_class
+            app.controller_class = Pyjoyment.Controller.object
+
+        Class to be used for the default controller, defaults to
+        :mod:`Pyjoyment.Controller`.
+        """
+
+        self.exception_format = 'html'
+        """::
+
+            format = app.exception_format
+            app.exception_format = 'txt'
+
+        Format for HTTP exceptions (``html``, ``json``, or ``txt``), defaults to
+        ``html``.
+        """
+
+        self.max_request_size: int | None = None
+        """::
+
+            max = app.max_request_size
+            app.max_request_size = 16777216
+
+        Maximum request size in bytes, defaults to the value of
+        :attr:`Pyjo.Message.Pyjo_Message.max_message_size`. Setting the value
+        to ``0`` will allow requests of indefinite size. Note that increasing
+        this value can also drastically increase memory usage, should you for
+        example attempt to parse an excessively large request body with the
+        methods ``dom`` or ``json`` of :mod:`Pyjo.Message`.
+        """
+
+        self.plugins: Pyjoyment.Plugins.object = Pyjoyment.Plugins.new()
+        """::
+
+            plugins = app.plugins
+            app.plugins = Pyjoyment.Plugins.new()
+
+        The plugin manager, defaults to a :mod:`Pyjoyment.Plugins` object. See
+        the :meth:`plugin` method below if you want to load a plugin. ::
+
+            # Add another namespace to load plugins from
+            app.plugins.namespaces.append('MyApp.Plugin')
+        """
+
+        self.preload_namespaces: list[str] = []
+        """::
+
+            namespaces = app.preload_namespaces
+            app.preload_namespaces = ['MyApp.Controller']
+
+        Namespaces to preload classes from during application startup.
+        """
+
+        self.renderer: Pyjoyment.Renderer.object = Pyjoyment.Renderer.new()
+        """::
+
+            renderer = app.renderer
+            app.renderer = Pyjoyment.Renderer.new()
+
+        Used to render content, defaults to a :mod:`Pyjoyment.Renderer` object.
+        ::
+
+            # Enable compression
+            app.renderer.compress = True
+
+            # Add another "templates" directory
+            app.renderer.paths.append('/home/sri/templates')
+
+            # Add another "templates" directory with higher precedence
+            app.renderer.paths.insert(0, '/home/sri/themes/blue/templates')
+
+            # Add another class with templates in DATA section
+            app.renderer.classes.append('Pyjoyment.Plugin.Fun')
+        """
+
+        self.routes: Pyjoyment.Routes.object = Pyjoyment.Routes.new()
+        """::
+
+            routes = app.routes
+            app.routes = Pyjoyment.Routes.new()
+
+        The router, defaults to a :mod:`Pyjoyment.Routes` object. You use this
+        in your startup method to define the url endpoints for your
+        application. ::
+
+            # Add routes
+            r = app.routes
+            r.get('/foo/bar').to('test#foo', title='Hello Pyjo!')
+            r.post('/baz').to('test#baz')
+
+            # Add another namespace to load controllers from
+            app.routes.namespaces.append('MyApp.MyController')
+        """
+
+        self.sessions: Pyjoyment.Sessions.object = Pyjoyment.Sessions.new()
+        """::
+
+            sessions = app.sessions
+            app.sessions = Pyjoyment.Sessions.new()
+
+        Signed cookie based session manager, defaults to a
+        :mod:`Pyjoyment.Sessions` object. You can usually leave this alone, see
+        :meth:`Pyjoyment.Controller.Pyjoyment_Controller.session` for more
+        information about working with session data. ::
+
+            # Change name of cookie used for all sessions
+            app.sessions.cookie_name = 'mysession'
+
+            # Disable SameSite feature
+            app.sessions.samesite = None
+        """
+
+        self.static: Pyjoyment.Static.object = Pyjoyment.Static.new()
+        """::
+
+            static = app.static
+            app.static = Pyjoyment.Static.new()
+
+        For serving static files from your ``public`` directories, defaults to
+        a :mod:`Pyjoyment.Static` object. ::
+
+            # Serve static files only with a "/static" prefix
+            app.static.prefix = '/static'
+
+            # Add another "public" directory
+            app.static.paths.append('/home/sri/public')
+
+            # Add another "public" directory with higher precedence
+            app.static.paths.insert(0, '/home/sri/themes/blue/public')
+
+            # Add another class with static files in DATA section
+            app.static.classes.append('Pyjoyment.Plugin.Fun')
+
+            # Remove built-in favicon
+            del app.static.extra['favicon.ico']
+        """
+
+        self.types: Pyjoyment.Types.object = Pyjoyment.Types.new()
+        """::
+
+            types = app.types
+            app.types = Pyjoyment.Types.new()
+
+        Responsible for connecting file extensions with MIME types, defaults to
+        a :mod:`Pyjoyment.Types` object. ::
+
+            # Add custom MIME type
+            app.types.type('twt', 'text/tweet')
+        """
+
+        self.validator: Pyjoyment.Validator.object = Pyjoyment.Validator.new()
+        """::
+
+            validator = app.validator
+            app.validator = Pyjoyment.Validator.new()
+
+        Validate values, defaults to a :mod:`Pyjoyment.Validator` object. ::
+
+            # Add validation check
+            app.validator.add_check('foo', lambda v, name, value: value != 'foo')
+
+            # Add validation filter
+            app.validator.add_filter('quotemeta', lambda v, name, value: re.escape(value))
+        """
+
+        self._mode: str | None = None
+        self._secrets: list[str] | None = None
+        self._dispatch = False
+
+        super().__init__(attrs, **kwargs)
+
+        home = self.home
+        self.renderer.paths.append(home.child('templates').to_str())
+        self.static.paths.append(home.child('public').to_str())
+
+        # Default to controller and application namespace
+        package = Pyjo.App._package(type(self))  # pyright: ignore[reportPrivateUsage]
+        controller = f'{package}.Controller'
+        self.preload_namespaces = [controller]
+        self.routes.namespaces = [controller, package]
+
+        for plugin in ('HeaderCondition', 'DefaultHelpers', 'TagHelpers', 'EPLRenderer', 'EPRenderer'):
+            self.plugin(plugin)
+
+        # Not in Mojolicious: the renderer of template strings
+        self.plugin('PyRenderer')
+
+        # Exception handling should be first in chain
+        self.hook('around_dispatch', _exception)
+
+        self.startup()
+        self.warmup()
+
+    # Unlike Mojolicious: Mojo registers the helpers with Mojo::DynamicMethods, Python looks them up in the renderer
+    # when a method is not found
+    def __getattr__(self, name: str) -> Any:
+        renderer: Any = vars(self).get('renderer')
+        if not name.startswith('_') and renderer is not None and renderer.get_helper(name) is not None:
+            return getattr(self.build_controller(), name)
+        package = f'{type(self).__module__}.{type(self).__qualname__}'
+
+        # The location of the caller, which croak adds to the message, the one of the attribute for the type of a helper
+        caller = sys._getframe(1)  # pyright: ignore[reportPrivateUsage]
+        if caller.f_code is Pyjoyment.Controller._HELPER_GET and caller.f_back is not None:  # pyright: ignore[reportPrivateUsage]
+            caller = caller.f_back
+        at = f'at {caller.f_code.co_filename} line {caller.f_lineno}'
+
+        # Not in Mojolicious: the attribute or the helper that the name most likely meant
+        mean = ''
+        if not name.startswith('_'):
+            names = [*dir(self), *(h.split('.')[0] for h in renderer.helpers)] if renderer is not None else []
+            if (suggestion := Pyjo.Util._suggest(name, names)) is not None:  # pyright: ignore[reportPrivateUsage]
+                mean = f' Did you mean "{suggestion}"?'
+        raise AttributeError(
+            f'Can\'t locate object method "{name}" via package "{package}" {at}.{mean}\n', name=name, obj=self
+        )
+
+    @property
+    def commands(self) -> Pyjoyment.Commands.object:
+        """::
+
+            commands = app.commands
+            app.commands = Pyjoyment.Commands.new()
+
+        Command line interface for your application, defaults to a
+        :mod:`Pyjoyment.Commands` object. ::
+
+            # Add another namespace to load commands from
+            app.commands.namespaces.append('MyApp.Command')
+        """
+        if self._commands is None:
+            self._commands = Pyjoyment.Commands.new(app=self)
+        return self._commands
+
+    @commands.setter
+    def commands(self, value: Pyjoyment.Commands.object) -> None:
+        self._commands = value
+
+    @property
+    def log(self) -> Pyjo.Log.object:
+        """::
+
+            log = app.log
+            app.log = Pyjo.Log.new()
+
+        The logging layer of your application, defaults to a :mod:`Pyjo.Log`
+        object. The level will default to either the ``PYJO_LOG_LEVEL``
+        environment variable, ``trace`` if the :attr:`mode` is
+        ``development``, or ``info`` otherwise. All messages will be written to
+        ``sys.stderr`` by default. ::
+
+            # Log debug message
+            app.log.debug('It works')
+        """
+        if self._log is None:
+            # Reduced log output outside of development mode
+            log = Pyjo.Log.new()
+            if level := os.environ.get('PYJO_LOG_LEVEL'):
+                log.level = level
+            elif self.mode != 'development':
+                log.level = 'info'
+            self._log = log
+        return self._log
+
+    @log.setter
+    def log(self, value: Pyjo.Log.object) -> None:
+        self._log = value
+
+    @property
+    def mode(self) -> str:
+        """::
+
+            mode = app.mode
+            app.mode = 'production'
+
+        The operating mode for your application, defaults to a value from the
+        ``PYJO_MODE`` environment variable or ``development``.
+        """
+        # Left out from Mojolicious: PLACK_ENV, the mode of Plack, which Python has no counterpart of
+        if self._mode is None:
+            self._mode = os.environ.get('PYJO_MODE') or 'development'
+        return self._mode
+
+    @mode.setter
+    def mode(self, value: str) -> None:
+        self._mode = value
+
+    @property
+    def secrets(self) -> list[str]:
+        """::
+
+            secrets = app.secrets
+            app.secrets = [passphrase]
+
+        Secret passphrases used for signed cookies and the like, defaults to the
+        :attr:`moniker` of this application, which is not very secure, so you
+        should change it!!! As long as you are using the insecure default there
+        will be debug messages in the log file reminding you to change your
+        passphrase. Only the first passphrase is used to create new signatures,
+        but all of them for verification. So you can increase security without
+        invalidating all your existing signed cookies by rotating passphrases,
+        just add new ones to the front and remove old ones from the back. ::
+
+            # Rotate passphrases
+            app.secrets = ['new_passw0rd', 'old_passw0rd', 'very_old_passw0rd']
+        """
+        if self._secrets is None:
+            # Warn developers about insecure default
+            self.log.trace('Your secret passphrase needs to be changed (see FAQ for more)')
+
+            # Default to moniker
+            self._secrets = [self.moniker]
+        return self._secrets
+
+    @secrets.setter
+    def secrets(self, value: list[str]) -> None:
+        self._secrets = value
+
+    def any(self, *args: Any, **constraints: 'Pyjoyment.Routes.Pattern.Constraint') -> Pyjoyment.Routes.Route.object:
+        """::
+
+            route = app.any('/:foo', lambda c: ...)
+
+        Generate route with
+        :meth:`Pyjoyment.Routes.Route.Pyjoyment_Routes_Route.any` on
+        :attr:`routes`, takes the same arguments.
+        """
+        return self.routes.any(*args, **constraints)
+
+    def build_controller(self, tx: Any = None) -> Pyjoyment.Controller.object:
+        """::
+
+            c = app.build_controller()
+            c = app.build_controller(Pyjo.Transaction.HTTP.new())
+            c = app.build_controller(Pyjoyment.Controller.new())
+
+        Build default controller object with :attr:`controller_class`. ::
+
+            # Render template from application
+            foo = app.build_controller().render_to_string(template='foo')
+        """
+        # Embedded application
+        stash: dict[str, Any] = {}
+        if tx is not None and isinstance(tx, Pyjoyment.Controller.object):
+            stash, tx = tx.stash(), tx.tx
+
+        # Build default controller
+        stash.update(self.defaults())
+        cls = self.controller_class
+        if isinstance(cls, str):
+            cls = Pyjo.Loader._class(cls) or Pyjoyment.Controller.object  # pyright: ignore[reportPrivateUsage]
+        cls = cast(type[Pyjoyment.Controller.object], cls)
+        c = cls.new(app=self, stash=stash, tx=tx)
+        if c.tx is None:
+            # The controller keeps the transaction, as Mojo keeps it in the hash of the controller
+            c._own_tx = own = self.build_tx()  # pyright: ignore[reportPrivateUsage]
+            c.tx = own
+
+        return c
+
+    def build_tx(self) -> Pyjo.Transaction.HTTP.object:
+        """::
+
+            tx = app.build_tx()
+
+        Build :mod:`Pyjo.Transaction.HTTP` object and emit ``after_build_tx``
+        hook.
+        """
+        tx = Pyjo.Transaction.HTTP.new()
+        if (max := self.max_request_size) is not None:
+            tx.req.max_message_size = max
+        self.plugins.emit_hook('after_build_tx', tx, self)
+
+        return tx
+
+    # defaults(**values) with no values is defaults(), which the first overload types
+    @overload
+    def defaults(self) -> dict[str, Any]: ...  # pyright: ignore[reportOverlappingOverload]
+
+    @overload
+    def defaults(self, name: str, /) -> Any: ...
+
+    @overload
+    def defaults(self, values: dict[str, Any], /) -> Self: ...
+
+    @overload
+    def defaults(self, **values: Any) -> Self: ...
+
+    def defaults(self, *args: Any, **values: Any) -> Any:
+        """::
+
+            hash = app.defaults()
+            foo = app.defaults('foo')
+            app = app.defaults({'foo': 'bar', 'baz': 23})
+            app = app.defaults(foo='bar', baz=23)
+
+        Default values for
+        :meth:`Pyjoyment.Controller.Pyjoyment_Controller.stash`, assigned for
+        every new request. ::
+
+            # Remove value
+            foo = app.defaults().pop('foo')
+
+            # Assign multiple values at once
+            app.defaults(foo='test', bar=23)
+        """
+        return Pyjo.Util._stash('defaults', self, args, values)  # pyright: ignore[reportPrivateUsage]
+
+    def delete(self, *args: Any, **constraints: 'Pyjoyment.Routes.Pattern.Constraint') -> Pyjoyment.Routes.Route.object:
+        """::
+
+            route = app.delete('/:foo', lambda c: ...)
+
+        Generate route with
+        :meth:`Pyjoyment.Routes.Route.Pyjoyment_Routes_Route.delete` on
+        :attr:`routes`, takes the same arguments.
+        """
+        return self.routes.delete(*args, **constraints)
+
+    def dispatch(self, c: Pyjoyment.Controller.object) -> None:
+        """::
+
+            app.dispatch(Pyjoyment.Controller.new())
+
+        The heart of every :mod:`Pyjoyment` application, calls the
+        :attr:`static` and :attr:`routes` dispatchers for every request and
+        passes them a :mod:`Pyjoyment.Controller` object.
+        """
+        plugins = self.plugins.emit_hook('before_dispatch', c)
+
+        stash = c.stash()
+        if stash.get('mojo.rendered'):
+            return
+
+        # Try to find a static file
+        tx: Any = c.tx
+        if not tx.res.code and self.static.dispatch(c):
+            plugins.emit_hook('after_static', c)
+
+        # Start timer (ignore static files)
+        if not stash.get('mojo.static'):
+
+            def message() -> str:
+                req = c.req
+                method = req.method
+                path = req.url.path.to_abs_str()
+                c.helpers.timing.begin('mojo.timer')
+                return f'{method} "{path}"'
+
+            c.helpers.log().trace(message)
+
+        # Routes
+        plugins.emit_hook('before_routes', c)
+        if not (tx.res.code or self.routes.dispatch(c) or tx.res.code):
+            c.helpers.reply.not_found()
+
+    def get(self, *args: Any, **constraints: 'Pyjoyment.Routes.Pattern.Constraint') -> Pyjoyment.Routes.Route.object:
+        """::
+
+            route = app.get('/:foo', lambda c: ...)
+
+        Generate route with
+        :meth:`Pyjoyment.Routes.Route.Pyjoyment_Routes_Route.get` on
+        :attr:`routes`, takes the same arguments.
+        """
+        return self.routes.get(*args, **constraints)
+
+    def handler(self, tx: Any) -> None:
+        """::
+
+            app.handler(Pyjo.Transaction.HTTP.new())
+            app.handler(Pyjoyment.Controller.new())
+
+        Sets up the default controller and emits the ``around_dispatch`` hook
+        for every request.
+        """
+        # Dispatcher has to be last in the chain
+        if not self._dispatch:
+            self._dispatch = True
+            self.hook('around_action', _action)
+            self.hook('around_dispatch', _dispatch)
+
+        # Process with chain
+        c = self.build_controller(tx)
+        self.plugins.emit_chain('around_dispatch', c)
+
+        # Delayed response
+        if not c.stash().get('mojo.rendered'):
+            c.helpers.log().trace('Nothing has been rendered, expecting delayed response (see FAQ for more)')
+
+    @overload
+    def helper[F: Callable[..., Any]](self, name: str, cb: None = None) -> Callable[[F], F]: ...
+
+    @overload
+    def helper[F: Callable[..., Any]](self, name: str, cb: F) -> F: ...
+
+    def helper(self, name: str, cb: Callable[..., Any] | None = None) -> Any:
+        """::
+
+            app.helper('foo', lambda c, *args: ...)
+
+            @app.helper('foo')
+            def foo(c, *args): ...
+
+        Add or replace a helper that will be available as a method of the
+        controller object and the application object. For a full list of
+        helpers that are available by default see
+        :mod:`Pyjoyment.Plugin.DefaultHelpers` and
+        :mod:`Pyjoyment.Plugin.TagHelpers`. ::
+
+            # Helper
+            cache = {}
+            app.helper('cache', lambda c: cache)
+
+            # Application
+            app.cache()['foo'] = 'bar'
+            result = app.cache()['foo']
+
+            # Controller
+            c.cache()['foo'] = 'bar'
+            result = c.cache()['foo']
+        """
+        if cb is None:
+
+            def decorator(cb: Callable[..., Any]) -> Callable[..., Any]:
+                return self.helper(name, cb)
+
+            return decorator
+        self.renderer.add_helper(name, cb)
+        # Unlike Mojolicious: the helper is returned, the name of the decorated function, where Mojo returns the
+        # renderer, which its implementation happens to return
+        return cb
+
+    def hook(self, name: str, cb: Callable[..., Any] | None = None) -> Any:
+        """::
+
+            app.hook('after_dispatch', lambda c: ...)
+
+            @app.hook('after_dispatch')
+            def after_dispatch(c): ...
+
+        Extend :mod:`Pyjoyment` with hooks, which allow code to be shared with
+        all requests indiscriminately, for a full list of available hooks see
+        the hooks above. ::
+
+            # Dispatchers will not run if there's already a response code defined
+            @app.hook('before_dispatch')
+            def before_dispatch(c):
+                if re.search(r'do_not_dispatch', c.req.url.path.to_route()):
+                    c.render(text='Skipped static file server and router!')
+        """
+        return self.plugins.on(name, cb)
+
+    def options(
+        self, *args: Any, **constraints: 'Pyjoyment.Routes.Pattern.Constraint'
+    ) -> Pyjoyment.Routes.Route.object:
+        """::
+
+            route = app.options('/:foo', lambda c: ...)
+
+        Generate route with
+        :meth:`Pyjoyment.Routes.Route.Pyjoyment_Routes_Route.options` on
+        :attr:`routes`, takes the same arguments.
+        """
+        return self.routes.options(*args, **constraints)
+
+    def patch(self, *args: Any, **constraints: 'Pyjoyment.Routes.Pattern.Constraint') -> Pyjoyment.Routes.Route.object:
+        """::
+
+            route = app.patch('/:foo', lambda c: ...)
+
+        Generate route with
+        :meth:`Pyjoyment.Routes.Route.Pyjoyment_Routes_Route.patch` on
+        :attr:`routes`, takes the same arguments.
+        """
+        return self.routes.patch(*args, **constraints)
+
+    def plugin(self, name: str, conf: dict[str, Any] | None = None, /, **values: Any) -> Any:
+        """::
+
+            app.plugin('some_thing')
+            app.plugin('some_thing', foo=23)
+            app.plugin('some_thing', {'foo': 23})
+            app.plugin('SomeThing')
+            app.plugin('SomeThing', foo=23)
+            app.plugin('SomeThing', {'foo': 23})
+            app.plugin('MyApp.Plugin.SomeThing')
+            app.plugin('MyApp.Plugin.SomeThing', foo=23)
+            app.plugin('MyApp.Plugin.SomeThing', {'foo': 23})
+
+        Load a plugin, for a full list of example plugins included in the
+        :mod:`Pyjoyment` distribution see :mod:`Pyjoyment.Plugins`.
+        """
+        return self.plugins.register_plugin(name, self, conf, **values)
+
+    def post(self, *args: Any, **constraints: 'Pyjoyment.Routes.Pattern.Constraint') -> Pyjoyment.Routes.Route.object:
+        """::
+
+            route = app.post('/:foo', lambda c: ...)
+
+        Generate route with
+        :meth:`Pyjoyment.Routes.Route.Pyjoyment_Routes_Route.post` on
+        :attr:`routes`, takes the same arguments.
+        """
+        return self.routes.post(*args, **constraints)
+
+    def put(self, *args: Any, **constraints: 'Pyjoyment.Routes.Pattern.Constraint') -> Pyjoyment.Routes.Route.object:
+        """::
+
+            route = app.put('/:foo', lambda c: ...)
+
+        Generate route with
+        :meth:`Pyjoyment.Routes.Route.Pyjoyment_Routes_Route.put` on
+        :attr:`routes`, takes the same arguments.
+        """
+        return self.routes.put(*args, **constraints)
+
+    def query(self, *args: Any, **constraints: 'Pyjoyment.Routes.Pattern.Constraint') -> Pyjoyment.Routes.Route.object:
+        """::
+
+            route = app.query('/:foo', lambda c: ...)
+
+        Generate route with
+        :meth:`Pyjoyment.Routes.Route.Pyjoyment_Routes_Route.query` on
+        :attr:`routes`, takes the same arguments.
+        """
+        return self.routes.query(*args, **constraints)
+
+    def server(self, server: Pyjo.Server.object) -> None:
+        """::
+
+            app.server(Pyjo.Server.new())
+
+        Emits the ``before_server_start`` hook.
+        """
+        self.plugins.emit_hook('before_server_start', server, self)
+
+    # Not in Mojolicious: the end of the server, as server is its start
+    def server_stopped(self, server: Pyjo.Server.object) -> 'Pyjo.Promise.object | None':
+        """::
+
+            promise = app.server_stopped(Pyjo.Server.new())
+
+        Emits the ``after_server_stop`` hook, and returns a promise of the
+        promises that its callbacks return.
+        """
+        promises = [
+            promise
+            for cb in self.plugins.subscribers('after_server_stop')
+            if isinstance(promise := cb(server, self), Pyjo.Promise.object)
+        ]
+        return Pyjo.Promise.all_settled(*promises) if promises else None
+
+    def start(self, *args: str) -> Any:  # pyright: ignore[reportIncompatibleMethodOverride]
+        """::
+
+            app.start()
+            app.start(*sys.argv[1:])
+
+        Start the command line interface for your application. For a full list
+        of commands that are available by default see
+        :mod:`Pyjoyment.Commands`. Note that the options ``-h``/``--help``,
+        ``--home`` and ``-m``/``--mode``, which are shared by all commands,
+        will be parsed from ``sys.argv`` when :mod:`Pyjoyment.Commands` is
+        imported. ::
+
+            # Always start daemon
+            app.start('daemon', '-l', 'http://*:8080')
+
+        When the environment variable ``PYJO_APP_LOADER`` is set, as
+        :meth:`Pyjo.Server.Pyjo_Server.load_app` does, the application is
+        kept in :data:`Pyjo.Server.loaded_app` for the server instead.
+        """
+        self.static.warmup()
+        self.renderer.warmup()
+        return self.commands.run(*(args or sys.argv[1:]))
+
+    def startup(self) -> None:
+        """::
+
+            app.startup()
+
+        This is your main hook into the application, it will be called at
+        application startup. Meant to be overloaded in a subclass. ::
+
+            def startup(self): ...
+        """
+
+    @overload
+    def template[F: Callable[..., Any]](self, name: str, cb: None = None) -> Callable[[F], F]: ...
+
+    @overload
+    def template[F: Callable[..., Any]](self, name: str, cb: F) -> F: ...
+
+    # Not in Mojolicious: the templates of functions, for the handler "py"
+    def template(self, name: str, cb: Callable[..., Any] | None = None) -> Any:
+        """::
+
+            app.template('index.html', lambda c: t('<p>Hello!</p>'))
+
+            @app.template('index.html')
+            def index(c): ...
+
+        Add or replace a template of a function, which gets the controller
+        and the values of the stash that it names and returns a template
+        string, with
+        :meth:`Pyjoyment.Renderer.Pyjoyment_Renderer.add_template`, see
+        :mod:`Pyjoyment.Plugin.PyRenderer`. ::
+
+            # Template
+            @app.template('hello.html')
+            def hello(c, name):
+                return t('<p>Hello {name}!</p>')
+
+            # Controller
+            c.render('hello', name='Joe')
+        """
+        if cb is None:
+
+            def decorator(cb: Callable[..., Any]) -> Callable[..., Any]:
+                return self.template(name, cb)
+
+            return decorator
+        self.renderer.add_template(name, cb)
+        return cb
+
+    def under(self, *args: Any, **constraints: 'Pyjoyment.Routes.Pattern.Constraint') -> Pyjoyment.Routes.Route.object:
+        """::
+
+            route = app.under('/:foo', lambda c: ...)
+
+        Generate route with
+        :meth:`Pyjoyment.Routes.Route.Pyjoyment_Routes_Route.under` on
+        :attr:`routes`, takes the same arguments.
+        """
+        return self.routes.under(*args, **constraints)
+
+    def warmup(self) -> None:
+        """::
+
+            app.warmup()
+
+        Preload classes from :attr:`preload_namespaces` for future use.
+        """
+        for namespace in self.preload_namespaces:
+            Pyjo.Loader.load_classes(namespace)
+
+    def websocket(
+        self, *args: Any, **constraints: 'Pyjoyment.Routes.Pattern.Constraint'
+    ) -> Pyjoyment.Routes.Route.object:
+        """::
+
+            route = app.websocket('/:foo', lambda c: ...)
+
+        Generate route with
+        :meth:`Pyjoyment.Routes.Route.Pyjoyment_Routes_Route.websocket` on
+        :attr:`routes`, takes the same arguments.
+        """
+        return self.routes.websocket(*args, **constraints)
+
+
+def _action(next: Any, c: Pyjoyment.Controller.object, action: Callable[..., Any], last: bool) -> Any:
+    try:
+        val = action(c)
+    except TypeError as e:
+        # Not in Mojolicious: the arguments of an action, which Perl does not check, as the placeholders of the route
+        # as the arguments of another framework
+        hint = 'an action gets the controller only, which has the values of the placeholders in c.param(...)'
+        Pyjo.Util._call_hint(e, hint)  # pyright: ignore[reportPrivateUsage]
+        raise
+    # Not in Mojolicious: the response that an endpoint returns, as a view of another framework does, which the
+    # automatic rendering reports when it renders nothing
+    if last and issubclass(type(val), (str, bytes, dict, list, tuple)):
+        c.stash()['pyjo.returned'] = type(val).__name__
+    # Not in Mojolicious: an action that is a coroutine function runs as a promise, which async sub of Mojo returns
+    if inspect.iscoroutine(val):
+        val = Pyjo.Promise.new(val)
+    if isinstance(val, Pyjo.Promise.object):
+        val.catch(functools.partial(_reply_exception, c))
+    return val
+
+
+def _dispatch(next: Callable[[], Any], c: Pyjoyment.Controller.object) -> None:
+    c.app.dispatch(c)
+
+
+def _exception(next: Callable[[], Any], c: Pyjoyment.Controller.object) -> None:
+    try:
+        next()
+    except Exception as e:
+        c.helpers.reply.exception(e)
+
+
+def _reply_exception(c: Pyjoyment.Controller.object, e: Any) -> None:
+    c.helpers.reply.exception(e)
+
+
+new = Pyjoyment_App.new
+object = Pyjoyment_App