aresource 0.0.1__tar.gz

aresource-0.0.1/PKG-INFO

@@ -0,0 +1,60 @@
+Metadata-Version: 2.3
+Name: aresource
+Version: 0.0.1
+Summary: 
+Author: Peter Babka
+Author-email: 159peter951@gmail.com
+Requires-Python: >=3.13, <4.0
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.13
+Provides-Extra: aiohttp
+Provides-Extra: hocon
+Requires-Dist: aiohttp (>=3.0.0,<4.0.0) ; extra == "aiohttp"
+Requires-Dist: pyhocon (>=0.3.0,<0.4.0) ; extra == "hocon"
+Project-URL: Repository, https://github.com/xbabka01/aresource
+Description-Content-Type: text/markdown
+
+# aresource
+
+A Python project for resource management.
+
+## Project Structure
+
+```
+src/
+  aresource/
+tests/
+```
+
+## Installation
+
+Use [Poetry](https://python-poetry.org/) to install dependencies:
+
+```sh
+poetry install
+```
+
+## Usage
+
+Import and use the package in your Python code:
+
+```python
+from aresource import manager
+```
+
+## Testing
+
+Run tests with:
+
+```sh
+poetry run pytest
+```
+
+## Code Quality
+
+- Type checking: `poetry run mypy src/`
+- Linting: `poetry run ruff src/`
+
+## License
+
+MIT License

aresource-0.0.1/README.md

@@ -0,0 +1,44 @@
+# aresource
+
+A Python project for resource management.
+
+## Project Structure
+
+```
+src/
+  aresource/
+tests/
+```
+
+## Installation
+
+Use [Poetry](https://python-poetry.org/) to install dependencies:
+
+```sh
+poetry install
+```
+
+## Usage
+
+Import and use the package in your Python code:
+
+```python
+from aresource import manager
+```
+
+## Testing
+
+Run tests with:
+
+```sh
+poetry run pytest
+```
+
+## Code Quality
+
+- Type checking: `poetry run mypy src/`
+- Linting: `poetry run ruff src/`
+
+## License
+
+MIT License

aresource-0.0.1/pyproject.toml

@@ -0,0 +1,66 @@
+[project]
+name = "aresource"
+version = "0.0.1"
+description = ""
+authors = [
+    {name = "Peter Babka",email = "159peter951@gmail.com"}
+]
+readme = "README.md"
+requires-python = ">=3.13, <4.0"
+dependencies = [
+]
+
+[project.urls]
+repository = "https://github.com/xbabka01/aresource"
+
+[tool.poetry]
+packages = [{include = "aresource", from = "src"}]
+
+[tool.poetry.dependencies]
+aiohttp = { version = "^3.0.0", optional = true }
+pyhocon = { version = "^0.3.0", optional = true }
+
+
+[tool.poetry.extras]
+aiohttp = ["aiohttp"]
+hocon = ["pyhocon"]
+
+[tool.poetry.group.dev.dependencies]
+pytest = "^8.4.1"
+pytest-asyncio = "^1.0.0"
+pytest-cov = "^6.2.1"
+pytest-ruff = "^0.5"
+pytest-mypy = "^1.0.1"
+aiohttp = "^3.12.14"
+pyhocon = "^0.3.61"
+
+[tool.pytest.ini_options]
+addopts = "--strict-markers --tb=short --mypy --cov=aresource --cov-report=html  --cov-report=term --ruff --ruff-format"
+asyncio_mode = "auto"
+testpaths = ["tests", "src"]
+
+[tool.ruff]
+line-length = 99
+
+[tool.ruff.lint]
+select = ["E", "F", "W", "I", "N", "UP", "B", "C4", "T20", "SIM", "Q", "RUF"]
+ignore = []
+
+[tool.ruff.format]
+docstring-code-format = true
+
+[tool.mypy]
+python_version = "3.13"
+files = ["src/aresource", "tests"]
+strict = true
+warn_redundant_casts = true
+warn_unused_ignores = true
+warn_unreachable = true
+
+[[tool.mypy.overrides]]
+module = "pyhocon"
+ignore_missing_imports = true
+
+[build-system]
+requires = ["poetry-core>=2.0.0,<3.0.0"]
+build-backend = "poetry.core.masonry.api"

aresource-0.0.1/src/aresource/__init__.py

@@ -0,0 +1,3 @@
+from aresource.manager import BaseResource, ResourceManager
+
+__all__ = ["BaseResource", "ResourceManager"]

aresource-0.0.1/src/aresource/manager.py

@@ -0,0 +1,102 @@
+import contextlib
+import copy
+from abc import ABC, abstractmethod
+from ast import TypeVar
+from collections.abc import AsyncIterator
+from typing import Any, ClassVar, Self
+
+T = TypeVar("T")
+
+
+class BaseResource[T](ABC):
+    name: str | None = None
+
+    def __get__(self, instance: "ResourceManager", owner: "type[ResourceManager]") -> T:
+        return instance.get_resource(self.name)  # type: ignore[no-any-return]
+
+    def __set_name__(self, owner: "type[ResourceManager]", name: str) -> None:
+        owner.register_resource(name, self)
+
+    @abstractmethod
+    @contextlib.asynccontextmanager
+    async def acquire(self, manager: "ResourceManager") -> AsyncIterator[T]:
+        """Acquire the resource asynchronously."""
+        yield None  # type: ignore[misc]
+
+
+class ResourceManager:
+    _cls: Any = None
+    _resources: ClassVar[dict[str, tuple[BaseResource[Any], Any]]] = {}
+
+    def __init__(self) -> None:
+        self._exitstack: contextlib.AsyncExitStack | None = None
+
+    @classmethod
+    def register_resource(cls, name: str, resource: BaseResource[Any]) -> None:
+        """Register a resource with the manager."""
+        if not isinstance(resource, BaseResource):
+            raise TypeError(f"{resource.__name__} is not a subclass of BaseResource")
+        if name in cls._resources:
+            raise AttributeError(f"Resource {name} is already registered in {cls.__name__}")
+        # Create a copy of the class resources to avoid modifying the superclass
+        if cls._cls is not cls:
+            cls._resources = copy.deepcopy(cls._resources)
+            cls._cls = cls
+
+        cls._resources[name] = (resource, ...)
+        resource.name = name
+
+    def get_resource(self, name: str | None) -> Any:
+        """
+        Get the value of a registered resource by name.
+        """
+        if name not in self._resources:
+            raise AttributeError(f"Resource {name} is not registered in {self.__class__.__name__}")
+        value = self._resources[name][1]
+        if value is Ellipsis:
+            raise AttributeError(
+                f"Resource {name} is not initialized in {self.__class__.__name__}"
+            )
+        return value
+
+    def set_resource(self, name: str, value: Any) -> None:
+        """
+        Set the value of a registered resource by name.
+        Raises AttributeError if the resource is not registered.
+        """
+        if name not in self._resources:
+            raise AttributeError(f"Resource {name} is not registered in {self.__class__.__name__}")
+
+        resource = self._resources[name][0]
+        self._resources[name] = (resource, value)
+
+    async def setup(self) -> None:
+        await self.__aenter__()
+
+    async def __aenter__(self) -> Self:
+        """Asynchronously enter the resource manager context, acquiring all resources.
+        Each resource is acquired using its async context manager and set in the manager.
+        Returns self.
+        """
+        if self._exitstack is not None:
+            raise RuntimeError("ResourceManager is already set up")
+
+        self._exitstack = contextlib.AsyncExitStack()
+        for name, (resource, _) in self._resources.items():
+            value = await self._exitstack.enter_async_context(resource.acquire(self))
+            self.set_resource(name, value)
+        return self
+
+    async def aclose(self) -> None:
+        """Asynchronously close the resource manager, releasing all resources."""
+        await self.__aexit__()
+
+    async def __aexit__(self, *exc: Any) -> bool | None:
+        """Asynchronously exit the resource manager context, releasing all resources.
+        Delegates to the AsyncExitStack's __aexit__ method.
+        Returns the result of the exit stack's __aexit__.
+        """
+        if self._exitstack is not None:
+            await self._exitstack.__aexit__(*exc)
+        self._exitstack = None
+        return False  # Do not suppress exceptions

aresource-0.0.1/src/aresource/resources/aiohttp/session.py

@@ -0,0 +1,28 @@
+import contextlib
+from collections.abc import AsyncIterator, Callable
+from typing import Any
+
+from aiohttp import ClientSession
+
+from aresource.manager import BaseResource, ResourceManager
+
+
+class ClientSessionResource(BaseResource[ClientSession]):
+    """
+    Resource that provides an aiohttp ClientSession.
+    """
+
+    def __init__(
+        self, callback: Callable[[ResourceManager], dict[str, Any]] | None = None
+    ) -> None:
+        super().__init__()
+        self.callback = callback
+
+    @contextlib.asynccontextmanager
+    async def acquire(self, manager: "ResourceManager") -> AsyncIterator[ClientSession]:
+        kwargs = self.callback(manager) if self.callback else {}
+        session = ClientSession(**kwargs)
+        try:
+            yield session
+        finally:
+            await session.close()  # Ensure the session is closed after use

aresource-0.0.1/src/aresource/resources/aiohttp/web.py

@@ -0,0 +1,42 @@
+import contextlib
+from collections.abc import AsyncIterator, Callable
+from typing import Any
+
+from aiohttp import web
+
+from aresource.manager import BaseResource, ResourceManager
+
+
+class WebAppResource(BaseResource[web.Application]):
+    """
+    Resource that provides an aiohttp ClientSession.
+    """
+
+    def __init__(
+        self,
+        routes: Callable[[ResourceManager], web.RouteTableDef],
+        callback: Callable[[ResourceManager], dict[str, Any]] | None = None,
+    ) -> None:
+        super().__init__()
+        self.callback = callback
+        self.routes = routes
+
+    @contextlib.asynccontextmanager
+    async def acquire(self, manager: "ResourceManager") -> AsyncIterator[web.Application]:
+        kwargs = self.callback(manager) if self.callback else {}
+        app = web.Application(**kwargs)
+
+        routes = self.routes(manager)
+        app.add_routes(routes)
+
+        runner = web.AppRunner(app)
+
+        await runner.setup()
+        site = web.TCPSite(runner, "localhost", 8081)
+
+        try:
+            await site.start()
+            yield app
+        finally:
+            await site.stop()
+            await app.shutdown()

aresource-0.0.1/src/aresource/resources/files/__init__.py

@@ -0,0 +1,21 @@
+from .base import BasePathResource
+from .bytes import BytesResource
+from .ini import IniResource
+from .json import JsonResource
+from .path import PathResource
+
+__all__ = [
+    "BasePathResource",
+    "BytesResource",
+    "HoconResource",
+    "IniResource",
+    "JsonResource",
+    "PathResource",
+]
+
+try:
+    from .hocon import HoconResource
+except ImportError:
+    pass
+else:
+    __all__.append("HoconResource")

aresource-0.0.1/src/aresource/resources/files/base.py

@@ -0,0 +1,36 @@
+import contextlib
+from abc import ABCMeta
+from collections.abc import Iterator
+from importlib.resources import as_file, files
+from importlib.resources.abc import Traversable
+from pathlib import Path
+from typing import TypeVar
+
+from aresource.manager import BaseResource
+
+T = TypeVar("T")
+
+
+class BasePathResource[T](BaseResource[T], metaclass=ABCMeta):
+    def __init__(self, package: str, path: str) -> None:
+        super().__init__()
+        self.package = package
+        self.path = path
+
+    @property
+    def resource(self) -> Traversable:
+        """
+        Get the path to the resource in the package.
+        """
+        return files(self.package).joinpath(self.path)
+
+    @contextlib.contextmanager
+    def as_file(self) -> Iterator[Path]:
+        """
+        Context manager to yield the path to the resource as a file.
+        """
+        with as_file(self.resource) as resource_path:
+            yield resource_path
+
+    def read(self) -> bytes:
+        return self.resource.read_bytes()

aresource-0.0.1/src/aresource/resources/files/bytes.py

@@ -0,0 +1,15 @@
+import contextlib
+from collections.abc import AsyncIterator
+
+from aresource.manager import ResourceManager
+from aresource.resources.files.base import BasePathResource
+
+
+class BytesResource(BasePathResource[bytes]):
+    """
+    Resource that provides a binary file in a package.
+    """
+
+    @contextlib.asynccontextmanager
+    async def acquire(self, manager: "ResourceManager") -> AsyncIterator[bytes]:
+        yield self.read()

aresource-0.0.1/src/aresource/resources/files/hocon.py

@@ -0,0 +1,17 @@
+import contextlib
+from collections.abc import AsyncIterator
+
+from pyhocon import ConfigFactory, ConfigTree
+
+from aresource.manager import ResourceManager
+from aresource.resources.files.base import BasePathResource
+
+
+class HoconResource(BasePathResource[ConfigTree]):
+    """
+    Resource that provides a JSON file in a package.
+    """
+
+    @contextlib.asynccontextmanager
+    async def acquire(self, manager: "ResourceManager") -> AsyncIterator[ConfigTree]:
+        yield ConfigFactory.parse_string(self.read().decode("utf-8"))

aresource-0.0.1/src/aresource/resources/files/ini.py

@@ -0,0 +1,19 @@
+import configparser
+import contextlib
+from collections.abc import AsyncIterator
+from configparser import ConfigParser
+
+from aresource.manager import ResourceManager
+from aresource.resources.files.base import BasePathResource
+
+
+class IniResource(BasePathResource[ConfigParser]):
+    """
+    Resource that provides a JSON file in a package.
+    """
+
+    @contextlib.asynccontextmanager
+    async def acquire(self, manager: "ResourceManager") -> AsyncIterator[ConfigParser]:
+        config = configparser.ConfigParser()
+        config.read_string(self.read().decode("utf-8"))
+        yield config

aresource-0.0.1/src/aresource/resources/files/json.py

@@ -0,0 +1,20 @@
+import contextlib
+import json
+from collections.abc import AsyncIterator
+from typing import Any
+
+from aresource.manager import ResourceManager
+from aresource.resources.files.base import BasePathResource
+
+
+class JsonResource(BasePathResource[dict[str, Any] | list[Any]]):
+    """
+    Resource that provides a JSON file in a package.
+    """
+
+    @contextlib.asynccontextmanager
+    async def acquire(
+        self, manager: "ResourceManager"
+    ) -> AsyncIterator[dict[str, Any] | list[Any]]:
+        data = self.read()
+        yield json.loads(data)

aresource-0.0.1/src/aresource/resources/files/path.py

@@ -0,0 +1,18 @@
+import contextlib
+from collections.abc import AsyncIterator
+from importlib.resources import as_file
+from pathlib import Path
+
+from aresource.manager import ResourceManager
+from aresource.resources.files.base import BasePathResource
+
+
+class PathResource(BasePathResource[Path]):
+    """
+    Resource that provides a path to a file in a package.
+    """
+
+    @contextlib.asynccontextmanager
+    async def acquire(self, manager: "ResourceManager") -> AsyncIterator[Path]:
+        with as_file(self.resource) as resource_path:
+            yield resource_path