muffin 0.102.3__tar.gz → 1.0.0__tar.gz

muffin-1.0.0/PKG-INFO

@@ -0,0 +1,187 @@
+Metadata-Version: 2.3
+Name: muffin
+Version: 1.0.0
+Summary: Muffin is a fast, simple and asyncronous web-framework for Python 3 (asyncio, trio, curio)
+License: MIT
+Keywords: asgi,web,web framework,asyncio,trio,curio
+Author: Kirill Klenov
+Author-email: horneds@gmail.com
+Requires-Python: >=3.10,<4.0
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Framework :: AsyncIO
+Classifier: Framework :: Trio
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: Implementation :: PyPy
+Classifier: Topic :: Internet :: WWW/HTTP
+Provides-Extra: standard
+Requires-Dist: asgi-tools (>=1.3.2,<2.0.0)
+Requires-Dist: gunicorn (>=20.1.0,<21.0.0) ; extra == "standard"
+Requires-Dist: modconfig (>=1,<2)
+Requires-Dist: ujson
+Requires-Dist: uvicorn[standard] (>=0.21.1,<0.22.0) ; extra == "standard"
+Project-URL: Documentation, https://klen.github.io/muffin
+Project-URL: Homepage, https://github.com/klen/muffin
+Project-URL: Repository, https://github.com/klen/muffin
+Project-URL: changelog, https://raw.githubusercontent.com/klen/muffin/master/CHANGELOG.md
+Description-Content-Type: text/x-rst
+
+.. image:: https://raw.github.com/klen/muffin/develop/docs/static/logo-h200.png
+   :height: 100px
+
+**Muffin** – fast, lightweight, and asynchronous ASGI_ web framework for Python 3.10+.
+
+.. image:: https://github.com/klen/muffin/workflows/tests/badge.svg
+    :target: https://github.com/klen/muffin/actions
+    :alt: Tests Status
+
+.. image:: https://github.com/klen/muffin/workflows/docs/badge.svg
+    :target: https://klen.github.io/muffin
+    :alt: Documentation Status
+
+.. image:: https://img.shields.io/pypi/v/muffin
+    :target: https://pypi.org/project/muffin/
+    :alt: PYPI Version
+
+.. image:: https://img.shields.io/pypi/pyversions/muffin
+    :target: https://pypi.org/project/muffin/
+    :alt: Python Versions
+
+----------
+
+Why Muffin?
+-----------
+
+Muffin combines the simplicity of microframeworks with native ASGI_ performance, supporting multiple async libraries (Asyncio_, Trio_, Curio_) out of the box. Its rich plugin ecosystem makes building modern web applications pleasant and efficient.
+
+Key Features
+------------
+
+- ASGI_ compatible
+- Competitive performance ([Benchmarks](http://klen.github.io/py-frameworks-bench/))
+- Supports Asyncio_, Trio_, and Curio_
+- Multiple response types: text, HTML, JSON, streams, files, SSE, WebSockets
+- First-class plugin system for templating, databases, auth, and more
+
+Installation
+------------
+
+Muffin requires **Python 3.10 or newer**. We recommend using the latest stable Python.
+
+Install via pip:
+
+.. code-block:: console
+
+    $ pip install muffin
+
+For the standard installation with `gunicorn`, `uvicorn`, `uvloop`, `httptools`:
+
+.. code-block:: console
+
+    $ pip install muffin[standard]
+
+Dependencies
+~~~~~~~~~~~~
+
+These packages will be installed automatically:
+
+* `ASGI-Tools`_ – ASGI toolkit
+* `Modconfig`_  – hierarchical configuration manager
+
+.. _ASGI-Tools: https://klen.github.io/asgi-tools/
+.. _Modconfig: https://pypi.org/project/modconfig/
+
+Quickstart
+----------
+
+Create a simple "Hello User" app:
+
+.. code-block:: python
+
+    import muffin
+
+    app = muffin.Application()
+
+    @app.route('/', '/hello/{name}')
+    async def hello(request):
+        name = request.path_params.get('name', 'world')
+        return f'Hello, {name.title()}!'
+
+Save this as `example.py` and run:
+
+.. code-block:: console
+
+    $ uvicorn example:app
+
+Visit http://localhost:8000 or http://localhost:8000/hello/username in your browser.
+
+Plugins
+-------
+
+Muffin has a rich ecosystem of plugins:
+
+- [`muffin-jinja2`](https://github.com/klen/muffin-jinja2) – Jinja2 templates (asyncio/trio/curio)
+- [`muffin-session`](https://github.com/klen/muffin-session) – Signed cookie-based HTTP sessions
+- [`muffin-oauth`](https://github.com/klen/muffin-oauth) – OAuth integration
+- [`muffin-sentry`](https://github.com/klen/muffin-sentry) – Sentry error tracking
+- [`muffin-peewee`](https://github.com/klen/muffin-peewee-aio) – Peewee ORM integration
+- [`muffin-babel`](https://github.com/klen/muffin-babel) – i18n support
+- [`muffin-databases`](https://github.com/klen/muffin-databases) – SQL database support
+- [`muffin-mongo`](https://github.com/klen/muffin-mongo) – MongoDB integration
+- [`muffin-rest`](https://github.com/klen/muffin-rest) – REST API utilities
+- [`muffin-redis`](https://github.com/klen/muffin-redis) – Redis integration
+- [`muffin-admin`](https://github.com/klen/muffin-admin) – Auto-generated admin UI
+- [`muffin-prometheus`](https://github.com/klen/muffin-prometheus) – Prometheus metrics exporter
+
+See each repo for usage and installation instructions.
+
+Benchmarks
+----------
+
+Performance comparisons are available at: http://klen.github.io/py-frameworks-bench/
+
+Bug tracker
+-----------
+
+Found a bug or have a feature request? Please open an issue at:
+https://github.com/klen/muffin/issues
+
+Contributing
+------------
+
+Contributions are welcome! Please see [CONTRIBUTING.md](https://github.com/klen/muffin/blob/develop/CONTRIBUTING.md) for guidelines.
+
+License
+-------
+
+Muffin is licensed under the MIT license.
+
+----------
+
+Credits
+-------
+
+**Muffin > 0.40 (completely rewritten on ASGI)**
+
+* `Kirill Klenov <https://github.com/klen>`_
+
+**Muffin < 0.40 (based on AIOHTTP_)**
+
+* `Kirill Klenov <https://github.com/klen>`_
+* `Andrew Grigorev <https://github.com/ei-grad>`_
+* `Diego Garcia <https://github.com/drgarcia1986>`_
+
+.. _AIOHTTP: https://docs.aiohttp.org/en/stable/
+.. _ASGI: https://asgi.readthedocs.io/en/latest/
+.. _Asyncio: https://docs.python.org/3/library/asyncio.html
+.. _Curio: https://curio.readthedocs.io/en/latest/
+.. _Python: http://python.org
+.. _Trio: https://trio.readthedocs.io/en/stable/index.html
+.. _MIT license: http://opensource.org/licenses/MIT
+

muffin-1.0.0/README.rst

@@ -0,0 +1,152 @@
+.. image:: https://raw.github.com/klen/muffin/develop/docs/static/logo-h200.png
+   :height: 100px
+
+**Muffin** – fast, lightweight, and asynchronous ASGI_ web framework for Python 3.10+.
+
+.. image:: https://github.com/klen/muffin/workflows/tests/badge.svg
+    :target: https://github.com/klen/muffin/actions
+    :alt: Tests Status
+
+.. image:: https://github.com/klen/muffin/workflows/docs/badge.svg
+    :target: https://klen.github.io/muffin
+    :alt: Documentation Status
+
+.. image:: https://img.shields.io/pypi/v/muffin
+    :target: https://pypi.org/project/muffin/
+    :alt: PYPI Version
+
+.. image:: https://img.shields.io/pypi/pyversions/muffin
+    :target: https://pypi.org/project/muffin/
+    :alt: Python Versions
+
+----------
+
+Why Muffin?
+-----------
+
+Muffin combines the simplicity of microframeworks with native ASGI_ performance, supporting multiple async libraries (Asyncio_, Trio_, Curio_) out of the box. Its rich plugin ecosystem makes building modern web applications pleasant and efficient.
+
+Key Features
+------------
+
+- ASGI_ compatible
+- Competitive performance ([Benchmarks](http://klen.github.io/py-frameworks-bench/))
+- Supports Asyncio_, Trio_, and Curio_
+- Multiple response types: text, HTML, JSON, streams, files, SSE, WebSockets
+- First-class plugin system for templating, databases, auth, and more
+
+Installation
+------------
+
+Muffin requires **Python 3.10 or newer**. We recommend using the latest stable Python.
+
+Install via pip:
+
+.. code-block:: console
+
+    $ pip install muffin
+
+For the standard installation with `gunicorn`, `uvicorn`, `uvloop`, `httptools`:
+
+.. code-block:: console
+
+    $ pip install muffin[standard]
+
+Dependencies
+~~~~~~~~~~~~
+
+These packages will be installed automatically:
+
+* `ASGI-Tools`_ – ASGI toolkit
+* `Modconfig`_  – hierarchical configuration manager
+
+.. _ASGI-Tools: https://klen.github.io/asgi-tools/
+.. _Modconfig: https://pypi.org/project/modconfig/
+
+Quickstart
+----------
+
+Create a simple "Hello User" app:
+
+.. code-block:: python
+
+    import muffin
+
+    app = muffin.Application()
+
+    @app.route('/', '/hello/{name}')
+    async def hello(request):
+        name = request.path_params.get('name', 'world')
+        return f'Hello, {name.title()}!'
+
+Save this as `example.py` and run:
+
+.. code-block:: console
+
+    $ uvicorn example:app
+
+Visit http://localhost:8000 or http://localhost:8000/hello/username in your browser.
+
+Plugins
+-------
+
+Muffin has a rich ecosystem of plugins:
+
+- [`muffin-jinja2`](https://github.com/klen/muffin-jinja2) – Jinja2 templates (asyncio/trio/curio)
+- [`muffin-session`](https://github.com/klen/muffin-session) – Signed cookie-based HTTP sessions
+- [`muffin-oauth`](https://github.com/klen/muffin-oauth) – OAuth integration
+- [`muffin-sentry`](https://github.com/klen/muffin-sentry) – Sentry error tracking
+- [`muffin-peewee`](https://github.com/klen/muffin-peewee-aio) – Peewee ORM integration
+- [`muffin-babel`](https://github.com/klen/muffin-babel) – i18n support
+- [`muffin-databases`](https://github.com/klen/muffin-databases) – SQL database support
+- [`muffin-mongo`](https://github.com/klen/muffin-mongo) – MongoDB integration
+- [`muffin-rest`](https://github.com/klen/muffin-rest) – REST API utilities
+- [`muffin-redis`](https://github.com/klen/muffin-redis) – Redis integration
+- [`muffin-admin`](https://github.com/klen/muffin-admin) – Auto-generated admin UI
+- [`muffin-prometheus`](https://github.com/klen/muffin-prometheus) – Prometheus metrics exporter
+
+See each repo for usage and installation instructions.
+
+Benchmarks
+----------
+
+Performance comparisons are available at: http://klen.github.io/py-frameworks-bench/
+
+Bug tracker
+-----------
+
+Found a bug or have a feature request? Please open an issue at:
+https://github.com/klen/muffin/issues
+
+Contributing
+------------
+
+Contributions are welcome! Please see [CONTRIBUTING.md](https://github.com/klen/muffin/blob/develop/CONTRIBUTING.md) for guidelines.
+
+License
+-------
+
+Muffin is licensed under the MIT license.
+
+----------
+
+Credits
+-------
+
+**Muffin > 0.40 (completely rewritten on ASGI)**
+
+* `Kirill Klenov <https://github.com/klen>`_
+
+**Muffin < 0.40 (based on AIOHTTP_)**
+
+* `Kirill Klenov <https://github.com/klen>`_
+* `Andrew Grigorev <https://github.com/ei-grad>`_
+* `Diego Garcia <https://github.com/drgarcia1986>`_
+
+.. _AIOHTTP: https://docs.aiohttp.org/en/stable/
+.. _ASGI: https://asgi.readthedocs.io/en/latest/
+.. _Asyncio: https://docs.python.org/3/library/asyncio.html
+.. _Curio: https://curio.readthedocs.io/en/latest/
+.. _Python: http://python.org
+.. _Trio: https://trio.readthedocs.io/en/stable/index.html
+.. _MIT license: http://opensource.org/licenses/MIT

{muffin-0.102.3 → muffin-1.0.0}/muffin/app.py

@@ -1,11 +1,12 @@
 """Implement Muffin Application."""
+
 from __future__ import annotations
 
 import logging
 from contextvars import ContextVar
-from inspect import isawaitable, stack
+from inspect import currentframe, isawaitable
 from logging.config import dictConfig
-from typing import TYPE_CHECKING, Any, Final, Mapping, Union
+from typing import TYPE_CHECKING, Any, Final, Mapping
 
 from asgi_tools import App as BaseApp
 from asgi_tools._compat import aio_wait
@@ -22,7 +23,7 @@ if TYPE_CHECKING:
 
     from muffin.plugins import BasePlugin
 
-BACKGROUND_TASK: Final["ContextVar[set[Awaitable] | None]"] = ContextVar(
+BACKGROUND_TASKS: Final[ContextVar[set[Awaitable[Any]] | None]] = ContextVar(
     "background_tasks", default=None
 )
 
@@ -50,7 +51,7 @@ class Application(BaseApp):
         "LOG_CONFIG": None,
     }
 
-    def __init__(self, *cfg_mods: Union[str, ModuleType], **options):
+    def __init__(self, *cfg_mods: str | ModuleType, **options):
         """Initialize the application.
 
         :param *cfg_mods: modules to import application's config
@@ -103,10 +104,10 @@ class Application(BaseApp):
     async def __call__(self, scope: TASGIScope, receive: TASGIReceive, send: TASGISend):
         """Support background tasks."""
         await self.lifespan(scope, receive, send)
-        bgtasks = BACKGROUND_TASK.get()
+        bgtasks = BACKGROUND_TASKS.get()
         if bgtasks is not None:
             await aio_wait(*bgtasks)
-            BACKGROUND_TASK.set(None)
+            BACKGROUND_TASKS.set(None)
 
     def import_submodules(self, *submodules: str, silent: bool = False, **kwargs):
         """Automatically import submodules.
@@ -125,9 +126,12 @@ class Application(BaseApp):
             app.import_submodules(silent=True)
 
         """
-        parent_frame = stack()[1][0]
-        package_name = parent_frame.f_locals["__name__"]
-        return import_submodules(package_name, *submodules, silent=silent, **kwargs)
+        curframe = currentframe()
+        if curframe:
+            parent_frame = curframe.f_back
+            if parent_frame:
+                package_name = parent_frame.f_locals["__name__"]
+                return import_submodules(package_name, *submodules, silent=silent, **kwargs)
 
     def run_after_response(self, *tasks: Awaitable):
         """Await the given awaitable after the response is completed.
@@ -154,11 +158,11 @@ class Application(BaseApp):
             return "OK"
 
         """
-        scheduled = BACKGROUND_TASK.get() or set()
+        scheduled = set(BACKGROUND_TASKS.get() or [])
         for task in tasks:
             if not isawaitable(task):
                 raise TypeError(f"Task must be awaitable: {task!r}")  # noqa: TRY003
 
             scheduled.add(task)
 
-        BACKGROUND_TASK.set(scheduled)
+        BACKGROUND_TASKS.set(scheduled)

{muffin-0.102.3 → muffin-1.0.0}/muffin/handler.py

@@ -3,9 +3,8 @@
 from __future__ import annotations
 
 import inspect
-from typing import TYPE_CHECKING, Any, Awaitable, Callable, Optional, cast
+from typing import TYPE_CHECKING, Any, Awaitable, Callable, cast
 
-from asgi_tools.utils import is_awaitable
 from asgi_tools.view import HTTP_METHODS, HTTPView
 
 from muffin.errors import AsyncRequiredError
@@ -34,7 +33,7 @@ class HandlerMeta(type):
         cls.methods = {method.upper() for method in cls.methods}
         for m in cls.methods:
             method = getattr(cls, m.lower(), None)
-            if method and not is_awaitable(method):
+            if method and not inspect.iscoroutinefunction(method):
                 raise AsyncRequiredError(method)
 
         return cls
@@ -50,7 +49,7 @@ class Handler(HTTPView, metaclass=HandlerMeta):
 
             async def get(self, request):
                 name = request.patch_params.get('name') or 'all'
-                return "GET: Hello f{name}"
+                return f"GET: Hello {name}"
 
             async def post(self, request):
                 name = request.patch_params.get('name') or 'all'
@@ -79,12 +78,10 @@ class Handler(HTTPView, metaclass=HandlerMeta):
 
     """
 
-    methods: Optional[TMethods] = None
+    methods: TMethods | None = None
 
     @classmethod
-    def __route__(
-        cls, router: Router, *paths: str, methods: Optional[TMethodsArg] = None, **params
-    ):
+    def __route__(cls, router: Router, *paths: str, methods: TMethodsArg | None = None, **params):
         """Check for registered methods."""
         router.bind(cls, *paths, methods=methods or cls.methods, **params)
         for _, method in inspect.getmembers(cls, lambda m: hasattr(m, "__route__")):
@@ -93,14 +90,14 @@ class Handler(HTTPView, metaclass=HandlerMeta):
 
         return cls
 
-    def __call__(self, request: Request, *, method_name: Optional[str] = None, **_) -> Awaitable:
+    def __call__(self, request: Request, *, method_name: str | None = None, **_) -> Awaitable:
         """Dispatch the given request by HTTP method."""
         method = getattr(self, method_name or request.method.lower())
         return method(request)
 
     @staticmethod
     def route(
-        *paths: str, methods: Optional[TMethodsArg] = None
+        *paths: str, methods: TMethodsArg | None = None
     ) -> Callable[[TVCallable], TVCallable]:
         """Mark a method as a route."""
 

{muffin-0.102.3 → muffin-1.0.0}/muffin/manage.py

@@ -1,4 +1,5 @@
 """CLI Support is here."""
+
 import argparse
 import code
 import inspect
@@ -9,7 +10,7 @@ import sys
 from contextlib import AsyncExitStack, suppress
 from importlib import metadata
 from pathlib import Path
-from typing import TYPE_CHECKING, AsyncContextManager, Callable, Optional, overload
+from typing import TYPE_CHECKING, AsyncContextManager, Callable, overload
 
 from muffin.constants import CONFIG_ENV_VARIABLE
 from muffin.errors import AsyncRequiredError
@@ -132,17 +133,15 @@ class Manager:
         return self(*args, **kwargs)
 
     @overload
-    def __call__(self, fn: "TVCallable") -> "TVCallable":
-        ...
+    def __call__(self, fn: "TVCallable") -> "TVCallable": ...
 
     @overload
-    def __call__(self, *, lifespan: bool = False) -> Callable[["TVCallable"], "TVCallable"]:
-        ...
+    def __call__(self, *, lifespan: bool = False) -> Callable[["TVCallable"], "TVCallable"]: ...
 
     def __call__(self, fn=None, *, lifespan=False):  # noqa: C901
         """Register a command."""
 
-        def wrapper(fn):  # noqa: C901
+        def wrapper(fn):  # noqa: PLR0912, C901
             if not inspect.iscoroutinefunction(fn) and lifespan:
                 raise AsyncRequiredError(fn)
 
@@ -157,57 +156,70 @@ class Manager:
                 return fn
 
             parser = self.subparsers.add_parser(command_name, description=description)
-            args, vargs, _, defs, __, kwdefs, anns = inspect.getfullargspec(fn)
-            defs = defs or []
-            kwargs_ = dict(zip(args[-len(defs) :], defs))
+            sig = inspect.signature(fn)
             docs = dict(PARAM_RE.findall(fn.__doc__ or ""))
 
-            def process_arg(name, *, value=..., **opts):
-                argname = name.lower()
+            for name, param in sig.parameters.items():
                 arghelp = docs.get(name, "")
-                if value is ...:
-                    return parser.add_argument(argname, help=arghelp, **opts)
-
-                argname = argname.replace("_", "-")
-                if isinstance(value, bool):
-                    if value:
-                        return parser.add_argument(
-                            "--no-" + argname,
-                            dest=name,
-                            action="store_false",
-                            help=arghelp or f"Disable { name }",
-                        )
-
-                    return parser.add_argument(
-                        "--" + argname,
-                        dest=name,
-                        action="store_true",
-                        help=arghelp or f"Enable { name }",
-                    )
+                argname = name.replace("_", "-")
 
-                if isinstance(value, list):
-                    return parser.add_argument(
-                        "--" + argname,
-                        action="append",
-                        default=value,
-                        help=arghelp,
-                    )
-
-                return parser.add_argument(
-                    "--" + argname,
-                    type=anns.get(name, type(value)),
-                    default=value,
-                    help=arghelp + " [%s]" % repr(value),
+                type_func = (
+                    param.annotation
+                    if param.annotation is not param.empty
+                    else type(param.default) if param.default is not param.empty else str
                 )
+                if not isinstance(type_func, type):
+                    type_func = str
 
-            if vargs:
-                process_arg("*", nargs="*", metavar=vargs)
+                if param.kind == param.VAR_POSITIONAL:
+                    parser.add_argument(name, nargs="*", metavar=name, help=arghelp)
+                    continue
 
-            for name, value in (kwdefs or {}).items():
-                process_arg(name, value=value)
+                if param.kind == param.VAR_KEYWORD:
+                    # **kwargs not supported in CLI parser
+                    continue
 
-            for name in args:
-                process_arg(name, value=kwargs_.get(name, ...))
+                if param.default is param.empty:
+                    parser.add_argument(
+                        name,
+                        help=arghelp,
+                        type=type_func,
+                    )
+                else:
+                    default = param.default
+                    if isinstance(default, bool):
+                        if default:
+                            parser.add_argument(
+                                f"--no-{argname}",
+                                dest=name,
+                                action="store_false",
+                                help=arghelp or f"Disable {name}",
+                            )
+                        else:
+                            parser.add_argument(
+                                f"--{argname}",
+                                dest=name,
+                                action="store_true",
+                                help=arghelp or f"Enable {name}",
+                            )
+                    elif isinstance(default, list):
+                        parser.add_argument(
+                            f"--{argname}",
+                            action="append",
+                            default=default,
+                            help=arghelp,
+                        )
+                    else:
+                        parser.add_argument(
+                            f"--{argname}",
+                            type=(
+                                param.annotation
+                                if param.annotation is not param.empty
+                                else type(default)
+                            ),
+                            default=default,
+                            help=f"{arghelp} [{default!r}]",
+                        )
 
             self.commands[command_name] = fn
             fn.parser = parser
@@ -218,7 +230,7 @@ class Manager:
 
         return wrapper
 
-    def run(self, *args: str, prog: Optional[str] = None):  # noqa: FA100
+    def run(self, *args: str, prog: str | None = None):
         """Parse the arguments and run a command."""
         if prog:
             self.parser.prog = prog