anyquart 0.1.0__tar.gz → 0.2.0__tar.gz

{anyquart-0.1.0 → anyquart-0.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: anyquart
-Version: 0.1.0
+Version: 0.2.0
 Summary: A fork of Quart that uses AnyIO
 Author-email: pgjones <philip.graham.jones@googlemail.com>, NIYONSHUTI Emmanuel <emmanuelniyonshuti13@gmail.com>
 Maintainer-email: NIYONSHUTI Emmanuel <emmanuelniyonshuti13@gmail.com>
@@ -40,7 +40,16 @@ Quart runs on Asyncio and when you want to run it on Trio event loop you use [qu
 
 AnyQuart is [Quart](https://github.com/pallets/quart) running on [AnyIO](https://github.com/agronholm/anyio). It is a fork of Quart 0.20.1.
 
-All credit for Quart goes to the [Pallets](https://palletsprojects.com) team.
+
+
+## Differences from Quart
+`AnyQuart` and `Quart` are essentially the same thing. The only difference is the name and the internals(Asyncio replaced with AnyIO). This also means the testing setup changes, which is explained in the [Testing](#testing) section below.
+
+- Works with both asyncio and Trio code via AnyIO, giving you structured concurrency out of the box.
+- Uses [Anycorn](https://github.com/davidbrochart/anycorn) instead of Hypercorn as the development server.
+- [aiofiles](https://github.com/Tinche/aiofiles) dropped, AnyIO's file I/O is used instead.
+- [pytest-asyncio](https://github.com/pytest-dev/pytest-asyncio) replaced by [AnyIO pytest plugin](https://anyio.readthedocs.io/en/stable/testing.html).
+- Runs on Python 3.10+ .
 
 ## Usage
 You will have to replace `quart` with `anyquart` and `Quart` with `AnyQuart`.
@@ -79,8 +88,8 @@ $ anyquart run
 ```
 
 # Testing
-Pytest does not natively support async test functions hence we need an async framework for async tests and fixtures.
-Quart uses pytest-asyncio, here we use AnyIO's pytest plugin. You will need to specify which backend your tests run on via the `anyio_backend` fixture and decorate your asynchronous tests with `@pytest.mark.anyio`.
+Pytest requires a plugin to run asynchronous test functions and fixtures.
+Quart uses pytest-asyncio, while AnyQuart uses AnyIO's pytest plugin. You will need to specify which backend your tests run on via the `anyio_backend` fixture and decorate your asynchronous tests with `@pytest.mark.anyio`.
 
 ```python
 import pytest
@@ -103,12 +112,20 @@ async def test_do_something(test_client) -> None:
 
 ```
 
-## Differences from Quart
-- Uses [Anycorn](https://github.com/davidbrochart/anycorn) instead of Hypercorn as the development server
-- Works with both asyncio and Trio via AnyIO
-- Uses AnyIO's file I/O instead of aiofiles
-- AnyIO primitives work freely in route handlers, giving you structured concurrency out of the box
-- Tests need `@pytest.mark.anyio` and the `anyio_backend` fixture instead of pytest-asyncio
-
 Refer to the [Quart documentation](https://quart.palletsprojects.com) for more details.
 
+## Contributing
+Issues and Pull Requests are welcome.
+
+## Contributors ✨
+
+<details>
+  <summary>See All Contributors</summary>
+
+  <div align="center">
+    <a href="https://github.com/EmmanuelNiyonshuti/anyquart/graphs/contributors?all=1">
+      <img src="https://contrib.rocks/image?repo=EmmanuelNiyonshuti/anyquart"/>
+    </a>
+  </div>
+</details>
+

{anyquart-0.1.0 → anyquart-0.2.0}/README.md

@@ -4,7 +4,16 @@ Quart runs on Asyncio and when you want to run it on Trio event loop you use [qu
 
 AnyQuart is [Quart](https://github.com/pallets/quart) running on [AnyIO](https://github.com/agronholm/anyio). It is a fork of Quart 0.20.1.
 
-All credit for Quart goes to the [Pallets](https://palletsprojects.com) team.
+
+
+## Differences from Quart
+`AnyQuart` and `Quart` are essentially the same thing. The only difference is the name and the internals(Asyncio replaced with AnyIO). This also means the testing setup changes, which is explained in the [Testing](#testing) section below.
+
+- Works with both asyncio and Trio code via AnyIO, giving you structured concurrency out of the box.
+- Uses [Anycorn](https://github.com/davidbrochart/anycorn) instead of Hypercorn as the development server.
+- [aiofiles](https://github.com/Tinche/aiofiles) dropped, AnyIO's file I/O is used instead.
+- [pytest-asyncio](https://github.com/pytest-dev/pytest-asyncio) replaced by [AnyIO pytest plugin](https://anyio.readthedocs.io/en/stable/testing.html).
+- Runs on Python 3.10+ .
 
 ## Usage
 You will have to replace `quart` with `anyquart` and `Quart` with `AnyQuart`.
@@ -43,8 +52,8 @@ $ anyquart run
 ```
 
 # Testing
-Pytest does not natively support async test functions hence we need an async framework for async tests and fixtures.
-Quart uses pytest-asyncio, here we use AnyIO's pytest plugin. You will need to specify which backend your tests run on via the `anyio_backend` fixture and decorate your asynchronous tests with `@pytest.mark.anyio`.
+Pytest requires a plugin to run asynchronous test functions and fixtures.
+Quart uses pytest-asyncio, while AnyQuart uses AnyIO's pytest plugin. You will need to specify which backend your tests run on via the `anyio_backend` fixture and decorate your asynchronous tests with `@pytest.mark.anyio`.
 
 ```python
 import pytest
@@ -67,11 +76,19 @@ async def test_do_something(test_client) -> None:
 
 ```
 
-## Differences from Quart
-- Uses [Anycorn](https://github.com/davidbrochart/anycorn) instead of Hypercorn as the development server
-- Works with both asyncio and Trio via AnyIO
-- Uses AnyIO's file I/O instead of aiofiles
-- AnyIO primitives work freely in route handlers, giving you structured concurrency out of the box
-- Tests need `@pytest.mark.anyio` and the `anyio_backend` fixture instead of pytest-asyncio
-
 Refer to the [Quart documentation](https://quart.palletsprojects.com) for more details.
+
+## Contributing
+Issues and Pull Requests are welcome.
+
+## Contributors ✨
+
+<details>
+  <summary>See All Contributors</summary>
+
+  <div align="center">
+    <a href="https://github.com/EmmanuelNiyonshuti/anyquart/graphs/contributors?all=1">
+      <img src="https://contrib.rocks/image?repo=EmmanuelNiyonshuti/anyquart"/>
+    </a>
+  </div>
+</details>

{anyquart-0.1.0 → anyquart-0.2.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "anyquart"
-version = "0.1.0"
+version = "0.2.0"
 description = "A fork of Quart that uses AnyIO"
 readme = "README.md"
 license = "MIT"
@@ -107,19 +107,12 @@ exclude_also = [
 ]
 
 [tool.mypy]
-python_version = "3.10"
-files = ["src", "tests"]
-show_error_codes = true
-pretty = true
+python_version = "3.14"
 strict = true
-# TODO fully satisfy strict mode and remove these customizations
-allow_redefinition = true
 disallow_any_generics = false
-disallow_untyped_calls = false
-implicit_reexport = true
-no_implicit_optional = true
 strict_optional = false
 warn_return_any = false
+files = ["src", "tests"]
 
 [tool.pyright]
 pythonVersion = "3.10"

{anyquart-0.1.0 → anyquart-0.2.0}/src/anyquart/app.py

@@ -9,7 +9,6 @@ from collections import defaultdict
 from collections.abc import AsyncGenerator
 from collections.abc import Awaitable
 from collections.abc import Callable
-from collections.abc import Coroutine
 from contextlib import AbstractAsyncContextManager
 from datetime import timedelta
 from inspect import isasyncgen
@@ -25,6 +24,7 @@ from typing import ParamSpec
 from typing import TypeVar
 from urllib.parse import quote
 
+import anyio
 from anycorn import serve
 from anycorn.config import Config as HyperConfig
 from anycorn.typing import ASGIReceiveCallable
@@ -37,8 +37,6 @@ from anyio import Event
 from anyio import Lock
 from anyio import open_file as async_open
 from anyio import open_signal_receiver
-from anyio import run
-from anyio import sleep
 from anyio.abc import TaskGroup
 from flask.sansio.app import App
 from flask.sansio.scaffold import setupmethod
@@ -123,9 +121,6 @@ from .typing import TestClientProtocol
 from .typing import WebsocketCallable
 from .typing import WhileServingCallable
 from .utils import file_path_to_path
-from .utils import MustReloadError
-from .utils import observe_changes
-from .utils import restart
 from .utils import run_sync
 from .wrappers import BaseRequestWebsocket
 from .wrappers import Request
@@ -384,7 +379,6 @@ class AnyQuart(App):
             return int(value.total_seconds())
 
         return value
-        return None
 
     async def send_static_file(self, filename: str) -> Response:
         if not self.has_static_folder:
@@ -781,13 +775,14 @@ class AnyQuart(App):
 
     def run(
         self,
-        host: str | None = None,
-        port: int | None = None,
-        debug: bool | None = None,
-        use_reloader: bool = True,
+        host: str = "127.0.0.1",
+        port: int = 5000,
+        debug: bool = False,
         ca_certs: str | None = None,
         certfile: str | None = None,
         keyfile: str | None = None,
+        use_reloader: bool | None = False,
+        app_import_path: str | None = None,
         **kwargs: Any,
     ) -> None:
         """Run this application.
@@ -819,7 +814,6 @@ class AnyQuart(App):
         if debug is not None:
             self.debug = debug
 
-        scheme = "https" if certfile is not None and keyfile is not None else "http"
         if host is None:
             server_name = self.config.get("SERVER_NAME")
             host = (
@@ -832,28 +826,21 @@ class AnyQuart(App):
 
         print(f" * Serving AnyQuart app '{self.name}'")
         print(f" * Debug mode: {self.debug or False}")
-        print(" * Please use an ASGI server (e.g. Hypercorn) directly in production")
+        print(" * Please use an ASGI server (e.g. Anycorn) directly in production")
+        scheme = "https" if certfile is not None and keyfile is not None else "http"
         print(f" * Running on {scheme}://{host}:{port} (CTRL + C to quit)")
 
-        reload_ = False
-        try:
-            run(
-                self._run_serve,
-                host,
-                port,
-                debug,
-                ca_certs,
-                certfile,
-                keyfile,
-                use_reloader,
-            )
-        except MustReloadError:
-            reload_ = True
+        if use_reloader:
+            from anycorn.run import run as anycorn_run
 
-        if reload_:
-            restart()
+            config = self._build_config(host, port, debug, ca_certs, certfile, keyfile)
+            config.use_reloader = True
+            config.application_path = app_import_path
+            anycorn_run(config)
+        else:
+            anyio.run(self._run_serve, host, port, debug, ca_certs, certfile, keyfile)
 
-    async def _run_serve(
+    def _build_config(
         self,
         host: str,
         port: int,
@@ -861,45 +848,30 @@ class AnyQuart(App):
         ca_certs: str | None,
         certfile: str | None,
         keyfile: str | None,
-        use_reloader: bool,
-    ) -> None:
-        shutdown_event = Event()
-
-        async def watch_signals() -> None:
-            with open_signal_receiver(signal.SIGINT, signal.SIGTERM) as signals:
-                async for _ in signals:
-                    shutdown_event.set()
-                    return
-
-        try:
-            async with create_task_group() as tg:
-                tg.start_soon(watch_signals)
-                tg.start_soon(
-                    self.run_task,
-                    host,
-                    port,
-                    debug,
-                    ca_certs,
-                    certfile,
-                    keyfile,
-                    shutdown_event.wait,
-                )
-                if use_reloader:
-                    tg.start_soon(observe_changes, sleep, shutdown_event)
-        except MustReloadError:
-            raise
+    ) -> HyperConfig:
+        config = HyperConfig()
+        config.access_log_format = "%(h)s %(r)s %(s)s %(b)s %(D)s"
+        config.accesslog = "-"
+        config.bind = [f"{host}:{port}"]
+        config.ca_certs = ca_certs
+        config.certfile = certfile
+        if debug is not None:
+            self.debug = debug
+            config.debug = debug
+        config.errorlog = config.accesslog
+        config.keyfile = keyfile
+        return config
 
-    def run_task(
+    async def _run_serve(
         self,
         host: str = "127.0.0.1",
         port: int = 5000,
-        debug: bool | None = None,
+        debug: bool = False,
         ca_certs: str | None = None,
         certfile: str | None = None,
         keyfile: str | None = None,
-        shutdown_trigger: Callable[..., Awaitable[None]] | None = None,
-    ) -> Coroutine[None, None, None]:
-        """Return a task that when awaited runs this application.
+    ) -> None:
+        """runs this application.
 
         This is best used for development only, see Hypercorn for
         production servers.
@@ -914,18 +886,19 @@ class AnyQuart(App):
             keyfile: Path to the SSL key file.
 
         """
-        config = HyperConfig()
-        config.access_log_format = "%(h)s %(r)s %(s)s %(b)s %(D)s"
-        config.accesslog = "-"
-        config.bind = [f"{host}:{port}"]
-        config.ca_certs = ca_certs
-        config.certfile = certfile
-        if debug is not None:
-            self.debug = debug
-        config.errorlog = config.accesslog
-        config.keyfile = keyfile
+        shutdown_event = Event()
 
-        return serve(self, config, shutdown_trigger=shutdown_trigger)
+        async def watch_signals() -> None:
+            with open_signal_receiver(signal.SIGINT, signal.SIGTERM) as signals:
+                async for _ in signals:
+                    shutdown_event.set()
+                    return
+
+        config = self._build_config(host, port, debug, ca_certs, certfile, keyfile)
+        async with create_task_group() as tg:
+            tg.start_soon(watch_signals)
+            await serve(self, config, shutdown_trigger=shutdown_event.wait)
+            tg.cancel_scope.cancel()
 
     def test_client(
         self, use_cookies: bool = True, **kwargs: Any
@@ -1170,7 +1143,7 @@ class AnyQuart(App):
         .. versionadded:: 0.11
 
         Override if you wish to change how synchronous functions are
-        run. Before anyquart 0.11 this did not run the synchronous code
+        run. Before quart 0.11 this did not run the synchronous code
         in an executor.
         """
         if iscoroutinefunction(func):
@@ -1367,7 +1340,12 @@ class AnyQuart(App):
         request.body.set_result(request_body)
         return self.request_context(request)
 
-    def add_background_task(self, func: Callable, *args: Any, **kwargs: Any) -> None:
+    def add_background_task(
+        self,
+        func: Callable[P, Awaitable[T]],
+        *args: P.args,
+        **kwargs: P.kwargs,
+    ) -> None:
         if self.background_tasks_tg is None:
             raise RuntimeError(
                 "Can not add background tasks before the app has started."
@@ -1436,7 +1414,9 @@ class AnyQuart(App):
 
         response: ResponseTypes
         if isinstance(value, HTTPException):
-            response = value.get_response()  # type: ignore
+            werkzeug_response = value.get_response()
+            assert isinstance(werkzeug_response, (Response, WerkzeugResponse))
+            response = werkzeug_response
         elif not isinstance(value, (Response, WerkzeugResponse)):
             if (
                 isinstance(value, (str, bytes, bytearray))

{anyquart-0.1.0 → anyquart-0.2.0}/src/anyquart/blueprints.py

@@ -85,7 +85,6 @@ class Blueprint(SansioBlueprint):
             return int(value.total_seconds())
 
         return value
-        return None
 
     async def send_static_file(self, filename: str) -> Response:
         if not self.has_static_folder:

{anyquart-0.1.0 → anyquart-0.2.0}/src/anyquart/cli.py

@@ -648,14 +648,29 @@ def run_command(
     if reload is None:
         reload = debug
 
-    app.run(
-        debug=debug,
-        host=host,
-        port=port,
-        certfile=certfile,
-        keyfile=keyfile,
-        use_reloader=reload,
-    )
+    if reload:
+        """
+        Delegating Development server reloading to Anycorn.
+        We need to provide the application path to Anycorn Config.
+        """
+        app.run(
+            debug=debug,
+            host=host,
+            port=port,
+            certfile=certfile,
+            keyfile=keyfile,
+            use_reloader=reload,
+            app_import_path=info.app_import_path,
+        )
+    else:
+        app.run(
+            debug=debug,
+            host=host,
+            port=port,
+            certfile=certfile,
+            keyfile=keyfile,
+            use_reloader=False,
+        )
 
 
 @click.command("shell", short_help="Run a shell in the app context.")

{anyquart-0.1.0 → anyquart-0.2.0}/src/anyquart/helpers.py

@@ -2,8 +2,6 @@ from __future__ import annotations
 
 import mimetypes
 import os
-import pkgutil
-import sys
 from collections.abc import Callable
 from collections.abc import Iterable
 from datetime import datetime
@@ -21,8 +19,8 @@ from zlib import adler32
 from flask.helpers import get_root_path as get_root_path  # noqa: F401
 from werkzeug.exceptions import abort as werkzeug_abort
 from werkzeug.exceptions import NotFound
+from werkzeug.security import safe_join
 from werkzeug.utils import redirect as werkzeug_redirect
-from werkzeug.utils import safe_join
 from werkzeug.wrappers import Response as WerkzeugResponse
 
 from .globals import _cv_request
@@ -232,32 +230,6 @@ def stream_with_context(func: Callable) -> Callable:
     return generator
 
 
-def find_package(name: str) -> tuple[Path | None, Path]:
-    """Finds packages install prefix (or None) and it's containing Folder"""
-    module = name.split(".")[0]
-    loader = pkgutil.get_loader(module)
-    if name == "__main__" or loader is None:
-        package_path = Path.cwd()
-    else:
-        if hasattr(loader, "get_filename"):
-            filename = loader.get_filename(module)
-        else:
-            __import__(name)
-            filename = sys.modules[name].__file__
-        package_path = Path(filename).resolve().parent
-        if hasattr(loader, "is_package"):
-            is_package = loader.is_package(module)
-            if is_package:
-                package_path = Path(package_path).resolve().parent
-    sys_prefix = Path(sys.prefix).resolve()
-    try:
-        package_path.relative_to(sys_prefix)
-    except ValueError:
-        return None, package_path
-    else:
-        return sys_prefix, package_path
-
-
 async def send_from_directory(
     directory: FilePath,
     file_name: str,

{anyquart-0.1.0 → anyquart-0.2.0}/src/anyquart/testing/connections.py

@@ -92,16 +92,15 @@ class TestHTTPConnection:
         if exc_type is not None:
             await self.disconnect()
         try:
-            await self._tg_cm.__aexit__(exc_type, exc_value, tb)
-            async for data in self._client_receive:
-                if isinstance(data, bytes):
-                    self.response_data.extend(data)
-                elif not isinstance(data, HTTPDisconnectError):
-                    raise data
+            with self._client_receive, self._client_send:
+                async for data in self._client_receive:
+                    if isinstance(data, bytes):
+                        self.response_data.extend(data)
+                    elif not isinstance(data, HTTPDisconnectError):
+                        raise data
         finally:
-            await self._client_receive.aclose()
             await self._server_receive.aclose()
-            await self._client_send.aclose()
+            await self._tg_cm.__aexit__(exc_type, exc_value, tb)
 
     async def as_response(self) -> Response:
         return self.app.response_class(

{anyquart-0.1.0 → anyquart-0.2.0}/src/anyquart/utils.py

@@ -2,10 +2,7 @@ from __future__ import annotations
 
 import inspect
 import os
-import platform
-import sys
 from collections.abc import AsyncIterator
-from collections.abc import Awaitable
 from collections.abc import Callable
 from collections.abc import Coroutine
 from collections.abc import Iterable
@@ -20,17 +17,12 @@ from typing import TypeVar
 import anyio
 from werkzeug.datastructures import Headers
 
-from .typing import Event
 from .typing import FilePath
 
 if TYPE_CHECKING:
     from .wrappers.response import Response  # noqa: F401
 
 
-class MustReloadError(Exception):
-    pass
-
-
 def file_path_to_path(*paths: FilePath) -> Path:
     # Flask supports bytes paths
     safe_paths: list[str | os.PathLike] = []
@@ -96,71 +88,3 @@ def encode_headers(headers: Headers) -> list[tuple[bytes, bytes]]:
 
 def decode_headers(headers: Iterable[tuple[bytes, bytes]]) -> Headers:
     return Headers([(key.decode(), value.decode()) for key, value in headers])
-
-
-async def observe_changes(
-    sleep: Callable[[float], Awaitable[Any]], shutdown_event: Event
-) -> None:
-    last_updates: dict[Path, float] = {}
-    for module in list(sys.modules.values()):
-        filename = getattr(module, "__file__", None)
-        if filename is None:
-            continue
-        path = Path(filename)
-        try:
-            last_updates[Path(filename)] = path.stat().st_mtime
-        except (FileNotFoundError, NotADirectoryError):
-            pass
-
-    while not shutdown_event.is_set():
-        await sleep(1)
-
-        for index, (path, last_mtime) in enumerate(last_updates.items()):
-            if index % 10 == 0:
-                # Yield to the event loop
-                await sleep(0)
-
-            try:
-                mtime = path.stat().st_mtime
-            except FileNotFoundError as e:
-                # File deleted
-                raise MustReloadError() from e
-            else:
-                if mtime > last_mtime:
-                    raise MustReloadError()
-                else:
-                    last_updates[path] = mtime
-
-
-def restart() -> None:
-    # Restart  this process (only safe for dev/debug)
-    executable = sys.executable
-    script_path = Path(sys.argv[0]).resolve()
-    args = sys.argv[1:]
-    main_package = sys.modules["__main__"].__package__
-
-    if main_package is None:
-        # Executed by filename
-        if platform.system() == "Windows":
-            if not script_path.exists() and script_path.with_suffix(".exe").exists():
-                # anyquart run
-                executable = str(script_path.with_suffix(".exe"))
-            else:
-                # python run.py
-                args = [str(script_path), *args]
-        else:
-            if script_path.is_file() and os.access(script_path, os.X_OK):
-                # anycorn run:app --reload
-                executable = str(script_path)
-            else:
-                # python run.py
-                args = [str(script_path), *args]
-    else:
-        # Executed as a module e.g. python -m run
-        module = script_path.stem
-        import_name = main_package
-        if module != "__main__":
-            import_name = f"{main_package}.{module}"
-        args[:0] = ["-m", import_name.lstrip(".")]
-
-    os.execv(executable, [executable] + args)

{anyquart-0.1.0 → anyquart-0.2.0}/src/anyquart/views.py

@@ -72,7 +72,7 @@ class View:
             self = cls(*class_args, **class_kwargs)
 
             async def view(**kwargs: Any) -> ResponseReturnValue:
-                return await current_app.ensure_async(self.dispatch_request)(**kwargs)
+                return await current_app.ensure_async(self.dispatch_request)(**kwargs)  # type: ignore
 
         if cls.decorators:
             view.__name__ = name

{anyquart-0.1.0 → anyquart-0.2.0}/src/anyquart/wrappers/response.py

@@ -6,7 +6,6 @@ from collections.abc import AsyncGenerator
 from collections.abc import AsyncIterable
 from collections.abc import AsyncIterator
 from collections.abc import Iterable
-from contextlib import AbstractAsyncContextManager
 from hashlib import md5
 from io import BytesIO
 from os import PathLike
@@ -145,18 +144,16 @@ class FileBody(ResponseBody):
         if buffer_size is not None:
             self.buffer_size = buffer_size
         self.file: AsyncFile[bytes] | None = None
-        self.file_manager: AbstractAsyncContextManager | None = None
 
     async def __aenter__(self) -> FileBody:
-        self.file_manager = await async_open(self.file_path, mode="rb")
-        self.file = await self.file_manager.__aenter__()
+        self.file = await async_open(self.file_path, mode="rb")
         await self.file.seek(self.begin)
         return self
 
     async def __aexit__(
         self, exc_type: type, exc_value: BaseException, tb: TracebackType
     ) -> None:
-        await self.file_manager.__aexit__(exc_type, exc_value, tb)
+        await self.file.aclose()
 
     def __aiter__(self) -> FileBody:
         return self