zayt 0.1.0__tar.gz

zayt-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2022 Livio Ribeiro
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

zayt-0.1.0/PKG-INFO

@@ -0,0 +1,76 @@
+Metadata-Version: 2.1
+Name: zayt
+Version: 0.1.0
+Summary: ASGI Web Framework with Dependency Injection
+Keywords: asgi,framework,asyncio,web
+Author: Livio Ribeiro
+License: MIT
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Web Environment
+Classifier: Framework :: AsyncIO
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: Topic :: Internet :: WWW/HTTP
+Classifier: Topic :: Internet :: WWW/HTTP :: Dynamic Content
+Classifier: Topic :: Software Development :: Libraries :: Application Frameworks
+Project-URL: Source, https://codeberg.org/python-zayt/zayt
+Project-URL: Documentation, https://python-zayt.codeberg.page/zayt
+Requires-Python: >=3.11
+Requires-Dist: asgikit~=0.18.0
+Requires-Dist: python-dotenv~=1.2.1
+Requires-Dist: structlog~=25.5.0
+Provides-Extra: jinja
+Requires-Dist: jinja2~=3.1.6; extra == "jinja"
+Provides-Extra: sqlalchemy
+Requires-Dist: SQLAlchemy[asyncio]~=2.0.45; extra == "sqlalchemy"
+Provides-Extra: redis
+Requires-Dist: redis~=7.1.0; extra == "redis"
+Provides-Extra: memcached
+Requires-Dist: aiomcache~=0.8.2; extra == "memcached"
+Description-Content-Type: text/markdown
+
+# Project Zayt
+
+Zayt is a Python ASGI web framework built on top of [asgikit](https://pypi.org/project/asgikit/)
+and inspired by Spring Boot, AspNet, FastAPI and Go's net/http.
+
+It features a Dependency Injection system to help build robust and reliable applications.
+
+## Quick start
+
+Install `zayt` and `uvicorn` to run application:
+
+```shell
+pip install zayt uvicorn[standard]
+```
+
+Create a module called `application.py`:
+
+```shell
+touch application.py
+```
+
+Create a handler:
+
+```python
+from asgikit import Request
+from zayt.web import get
+
+
+@get
+async def hello(request: Request):
+    await request.respond_text("Hello, World!")
+```
+
+Run application with `uvicorn` (Zayt will automatically load `application.py`):
+
+```shell
+uvicorn zayt.run:app --reload
+```

zayt-0.1.0/README.md

@@ -0,0 +1,38 @@
+# Project Zayt
+
+Zayt is a Python ASGI web framework built on top of [asgikit](https://pypi.org/project/asgikit/)
+and inspired by Spring Boot, AspNet, FastAPI and Go's net/http.
+
+It features a Dependency Injection system to help build robust and reliable applications.
+
+## Quick start
+
+Install `zayt` and `uvicorn` to run application:
+
+```shell
+pip install zayt uvicorn[standard]
+```
+
+Create a module called `application.py`:
+
+```shell
+touch application.py
+```
+
+Create a handler:
+
+```python
+from asgikit import Request
+from zayt.web import get
+
+
+@get
+async def hello(request: Request):
+    await request.respond_text("Hello, World!")
+```
+
+Run application with `uvicorn` (Zayt will automatically load `application.py`):
+
+```shell
+uvicorn zayt.run:app --reload
+```

zayt-0.1.0/pyproject.toml

@@ -0,0 +1,117 @@
+[project]
+name = "zayt"
+description = "ASGI Web Framework with Dependency Injection"
+authors = [
+    { name = "Livio Ribeiro" },
+]
+readme = "README.md"
+keywords = [
+    "asgi",
+    "framework",
+    "asyncio",
+    "web",
+]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Environment :: Web Environment",
+    "Framework :: AsyncIO",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Programming Language :: Python :: 3.14",
+    "Programming Language :: Python :: Implementation :: CPython",
+    "Topic :: Internet :: WWW/HTTP",
+    "Topic :: Internet :: WWW/HTTP :: Dynamic Content",
+    "Topic :: Software Development :: Libraries :: Application Frameworks",
+]
+dynamic = []
+requires-python = ">=3.11"
+dependencies = [
+    "asgikit~=0.18.0",
+    "python-dotenv~=1.2.1",
+    "structlog~=25.5.0",
+]
+version = "0.1.0"
+
+[project.license]
+text = "MIT"
+
+[project.urls]
+Source = "https://codeberg.org/python-zayt/zayt"
+Documentation = "https://python-zayt.codeberg.page/zayt"
+
+[project.optional-dependencies]
+jinja = [
+    "jinja2~=3.1.6",
+]
+sqlalchemy = [
+    "SQLAlchemy[asyncio]~=2.0.45",
+]
+redis = [
+    "redis~=7.1.0",
+]
+memcached = [
+    "aiomcache~=0.8.2",
+]
+
+[dependency-groups]
+dev = [
+    "uvicorn[standard]~=0.40",
+    "granian~=2.5",
+]
+test = [
+    "pytest~=9.0.0",
+    "pytest-asyncio~=1.3.0",
+    "pytest-mock~=3.15.1",
+    "pytest-cov~=7.0.0",
+    "httpx~=0.28.1",
+    "httpx-ws~=0.8.2",
+    "aiosqlite~=0.22.0",
+    "asyncpg~=0.31.0",
+]
+lint = [
+    "pylint~=4.0",
+    "ruff~=0.14",
+    "mypy~=1.19",
+    "isort~=7.0",
+]
+docs = [
+    "sphinx~=9.0.4",
+    "sphinx-intl~=2.3.2",
+    "sphinx-autobuild>=2025.8.25",
+]
+
+[tool.pdm]
+distribution = true
+
+[tool.pdm.version]
+source = "file"
+path = "src/zayt/__version__.py"
+
+[tool.pdm.scripts]
+test = "pytest --cov src --cov-report term --cov-report html"
+
+[tool.pdm.scripts.docs]
+shell = "    sphinx-autobuild --doctree-dir=docs/_build/doctrees --post-build='{pdm} run docs/build_locales.py' docs docs/_build/html\n"
+
+[tool.pdm.scripts.docs-build]
+composite = [
+    "sphinx-build -d docs/_build/doctrees/en/ docs docs/_build/html",
+    "{pdm} run docs/build_locales.py",
+]
+
+[tool.pdm.scripts.docs-intl]
+composite = [
+    "sphinx-build -M gettext docs docs/_build",
+    "sphinx-intl update -d docs/_locale -p docs/_build/gettext -l pt_BR",
+]
+
+[build-system]
+requires = [
+    "pdm-backend",
+]
+build-backend = "pdm.backend"

zayt-0.1.0/src/zayt/__version__.py

@@ -0,0 +1 @@
+__version__ = "0.1.0"

zayt-0.1.0/src/zayt/conf/__init__.py

@@ -0,0 +1,2 @@
+from zayt.conf.environment import env  # noqa: F401
+from zayt.conf.settings import Settings  # noqa: F401

zayt-0.1.0/src/zayt/conf/defaults.py

@@ -0,0 +1,24 @@
+default_settings = {
+    "__application__": "application",
+    "extensions": [],
+    "asgi_middleware": [],
+    "logging": {
+        "setup": "zayt.logging:setup",
+    },
+    "jinja": {},
+    "memcached": {},
+    "redis": {},
+    "sqlalchemy": {
+        "connections": {},
+        "session": {},
+    },
+    "staticfiles": {
+        "path": "/static",
+        "root": "resources/static",
+        "mappings": {},
+    },
+    "uploadedfiles": {
+        "path": "/uploads",
+        "root": "resources/uploads",
+    },
+}

zayt-0.1.0/src/zayt/conf/environment.py

@@ -0,0 +1,52 @@
+import json
+import os
+from collections.abc import Callable
+from typing import TypeVar
+
+T = TypeVar("T")
+
+
+def env(name: str, cast: Callable[[str], T] = str, default: T = None) -> T:
+    """Read an environment variable, optionally applying a cast
+
+    :param name: Name of the environment variable
+    :param cast: Type to convert the value
+        Should be a callable that accepts a ``str`` and returns the converted value.
+        :py:type:`bool` receives a special treatment:
+        If the value is empty, return ``None``.
+        If the value is ``"1"`` or ``"true"`` (ignoring case), the result is ``True``.
+        Any other value is ``False``.
+        :py:module:`json` also receives a special treatment, in which the value
+        is converted with ``json.loads``.
+    :param default: Default value if the environment variable is not set
+    """
+
+    value = os.environ.get(name)
+
+    if value is None:
+        if default is not None:
+            return default
+        raise ValueError(f"Environment variable '{name}' not set")
+
+    if len(value.strip()) == 0:
+        return None
+
+    if cast is bool:
+        return _cast_bool(value)
+
+    if cast is json:
+        return json.loads(value)
+
+    return cast(value)
+
+
+def _cast_bool(value: str) -> bool | None:
+    """Cast value to bool from str
+
+    :return:
+        True if `value.lower()` is "true" or "1"
+        None if `value.strip` is empty
+        False otherwise
+    """
+
+    return value.lower() in {"true", "1"}

zayt-0.1.0/src/zayt/conf/settings.py

@@ -0,0 +1,165 @@
+"""
+The processing of settings occur as follows:
+
+1. Get main settings values
+2. Recursively merge values with settings from profiles, in the order of declaration
+"""
+
+import copy
+import importlib.util
+import os
+from collections.abc import Mapping
+from copy import deepcopy
+from pathlib import Path
+from typing import Any
+
+from zayt.conf.defaults import default_settings
+
+__all__ = (
+    "Settings",
+    "SettingsError",
+    "get_settings",
+    "get_settings_meta",
+    "get_settings_for_profile",
+)
+
+SETTINGS_DIR_ENV = "ZAYT_SETTINGS_DIR"
+SETTINGS_FILE_ENV = "ZAYT_SETTINGS_FILE"
+
+DEFAULT_SETTINGS_DIR = str(Path("configuration"))
+DEFAULT_SETTINGS_FILE = "settings.py"
+SETTINGS_KEY = "settings"
+
+ZAYT_PROFILE_ENV = "ZAYT_PROFILE"
+
+
+class Settings(Mapping[str, Any]):
+    def __init__(self, data: dict):
+        self._original_data = copy.deepcopy(data)
+        self.__data = data
+
+        for key, value in data.items():
+            if isinstance(value, dict):
+                self.__data[key] = Settings(value)
+
+    def __getattr__(self, item: str):
+        try:
+            return self.__data[item]
+        except KeyError:
+            # pylint: disable=raise-missing-from
+            raise AttributeError(item)
+
+    def __len__(self) -> int:
+        return len(self.__data)
+
+    def __iter__(self):
+        return iter(self.__data)
+
+    def __contains__(self, key: str):
+        return key in self.__data
+
+    def __getitem__(self, key: str):
+        return self.__data[key]
+
+    def __copy__(self):
+        return Settings(copy.copy(self._original_data))
+
+    def __deepcopy__(self, memodict):
+        data = copy.deepcopy(self._original_data, memodict)
+        return Settings(data)
+
+    def __eq__(self, other: Any) -> bool:
+        if isinstance(other, Settings):
+            return self._original_data == other._original_data
+        if isinstance(other, Mapping):
+            return self._original_data == other
+
+        return False
+
+    def __str__(self):
+        return str(self.__data)
+
+    def __repr__(self):
+        return repr(self.__data)
+
+
+class SettingsError(Exception):
+    def __init__(self, path: Path):
+        super().__init__(f"cannot load settings from {path}")
+        self.path = path
+
+
+def get_settings() -> Settings:
+    """Get settings from files and environment"""
+    return get_settings_meta()[0]
+
+
+def get_settings_meta() -> tuple[Settings, list[tuple[Path, str | None, bool]]]:
+    """Get settings from files and environment with metadata
+
+    Metadata contains the files used to load settings from and if the file exists or not
+    """
+    # get default settings
+    settings = deepcopy(default_settings)
+    settings_files = []
+
+    # merge with main settings file (settings.yaml)
+    profile_settings, profile_settings_file = get_settings_for_profile()
+    _merge_recursive(settings, profile_settings)
+    settings_files.append(profile_settings_file)
+
+    # merge with profile settings files (settings_$ZAYT_PROFILE.yaml)
+    if active_profile_list := os.getenv(ZAYT_PROFILE_ENV):
+        for active_profile in active_profile_list.split(","):
+            active_profile = active_profile.strip()
+            profile_settings, profile_settings_file = get_settings_for_profile(
+                active_profile
+            )
+            _merge_recursive(settings, profile_settings)
+            settings_files.append(profile_settings_file)
+
+    return Settings(settings), settings_files
+
+
+def get_settings_for_profile(
+    profile: str = None,
+) -> tuple[dict, tuple[Path, str | None, bool]]:
+    settings_file = os.getenv(SETTINGS_FILE_ENV, DEFAULT_SETTINGS_FILE)
+    settings_dir_path = Path(os.getenv(SETTINGS_DIR_ENV, DEFAULT_SETTINGS_DIR))
+    settings_file_path = settings_dir_path / settings_file
+
+    if profile:
+        settings_file_path = settings_file_path.with_stem(
+            f"{settings_file_path.stem}_{profile}"
+        )
+
+    settings_file_path = settings_file_path.absolute()
+
+    try:
+        spec = importlib.util.spec_from_file_location(
+            "settings" if not profile else f"settings_{profile}",
+            settings_file_path,
+        )
+        settings_module = importlib.util.module_from_spec(spec)
+        spec.loader.exec_module(settings_module)
+
+        result = getattr(settings_module, SETTINGS_KEY, {})
+        if not isinstance(result, dict):
+            raise TypeError("invalid settings object type")
+        return result, (settings_file_path, profile, True)
+    except FileNotFoundError:
+        return {}, (settings_file_path, profile, False)
+    except TypeError as err:
+        raise SettingsError(settings_file_path) from err
+    except Exception as err:
+        raise SettingsError(settings_file_path) from err
+
+
+def _merge_recursive(destination: dict, source: dict):
+    for key in source:
+        if key in destination and all(
+            isinstance(arg[key], dict) for arg in (destination, source)
+        ):
+            _merge_recursive(destination[key], source[key])
+        else:
+            destination[key] = deepcopy(source[key])

zayt-0.1.0/src/zayt/di/__init__.py

@@ -0,0 +1,5 @@
+# ruff: noqa: F401
+
+from zayt.di.container import Container
+from zayt.di.decorator import service
+from zayt.di.inject import Inject

zayt-0.1.0/src/zayt/di/call.py

@@ -0,0 +1,25 @@
+from collections.abc import Callable
+from typing import Any
+
+from zayt.util.maybe_async import call_maybe_async
+from zayt.di.container import Container
+from zayt.di.service.parse import get_dependencies
+
+
+async def call_with_dependencies(
+    di: Container,
+    target: Callable,
+    *,
+    args: list | tuple = None,
+    context: Any = None,
+):
+    args = args or []
+
+    dependencies = {
+        name: await di.get(
+            dep.service, name=dep.name, optional=dep.optional, context=context
+        )
+        for name, dep in get_dependencies(target, skip=len(args))
+    }
+
+    return await call_maybe_async(target, *args, **dependencies)