alpha-python 0.3.4__py3-none-any.whl → 0.5.0__py3-none-any.whl

alpha/__init__.py

@@ -1,3 +1,4 @@
+from alpha.adapters.rest_api_unit_of_work import RestApiUnitOfWork
 from alpha.adapters.sqla_unit_of_work import SqlAlchemyUnitOfWork
 from alpha.factories.jwt_factory import JWTFactory
 from alpha.factories.logging_handler_factory import LoggingHandlerFactory
@@ -20,6 +21,7 @@ from alpha.interfaces.pydantic_instance import PydanticInstance
 from alpha.interfaces.openapi_model import OpenAPIModel
 from alpha.interfaces.updateable import Updateable
 from alpha.interfaces.patchable import Patchable
+from alpha.interfaces.api_repository import ApiRepository
 from alpha.interfaces.sql_repository import SqlRepository
 from alpha.interfaces.sql_mapper import SqlMapper
 from alpha.interfaces.sql_database import SqlDatabase
@@ -44,6 +46,7 @@ from alpha.providers.models.credentials import PasswordCredentials
 from alpha.providers.models.token import Token
 from alpha.providers.oidc_provider import OIDCProvider, KeyCloakProvider
 from alpha.repositories.models.repository_model import RepositoryModel
+from alpha.repositories.rest_api_repository import RestApiRepository
 from alpha.repositories.sql_alchemy_repository import SqlAlchemyRepository
 from alpha.services.authentication_service import AuthenticationService
 from alpha.utils.is_attrs import is_attrs
@@ -60,13 +63,20 @@ from alpha.encoder import JSONEncoder
 
 # Optional LDAP support - only import if ldap3 is available
 try:
-    from alpha.infra.connectors.ldap_connector import LDAPConnector  # noqa: F401
-    from alpha.providers.ldap_provider import LDAPProvider, ADProvider  # noqa: F401
+    from alpha.infra.connectors.ldap_connector import (
+        LDAPConnector,  # noqa: F401
+    )
+    from alpha.providers.ldap_provider import (
+        LDAPProvider,  # noqa: F401
+        ADProvider,  # noqa: F401
+    )
+
     _LDAP_AVAILABLE = True
 except ImportError:
-    _LDAP_AVAILABLE = False # type: ignore
+    _LDAP_AVAILABLE = False  # type: ignore
 
 __all__ = [
+    "RestApiUnitOfWork",
     "SqlAlchemyUnitOfWork",
     "JWTFactory",
     "LoggingHandlerFactory",
@@ -91,6 +101,7 @@ __all__ = [
     "OpenAPIModel",
     "Updateable",
     "Patchable",
+    "ApiRepository",
     "SqlRepository",
     "SqlMapper",
     "SqlDatabase",
@@ -112,6 +123,7 @@ __all__ = [
     "OIDCProvider",
     "KeyCloakProvider",
     "RepositoryModel",
+    "RestApiRepository",
     "SqlAlchemyRepository",
     "AuthenticationService",
     "is_attrs",
@@ -128,8 +140,10 @@ __all__ = [
 
 # Conditionally add LDAP-related exports if available
 if _LDAP_AVAILABLE:
-    __all__.extend([
-        "LDAPConnector",
-        "LDAPProvider",
-        "ADProvider",
-    ])
+    __all__.extend(
+        [
+            "LDAPConnector",
+            "LDAPProvider",
+            "ADProvider",
+        ]
+    )

alpha/adapters/__init__.py

@@ -1,5 +1,7 @@
+from alpha.adapters.rest_api_unit_of_work import RestApiUnitOfWork
 from alpha.adapters.sqla_unit_of_work import SqlAlchemyUnitOfWork
 
 __all__ = [
+    "RestApiUnitOfWork",
     "SqlAlchemyUnitOfWork",
 ]

alpha/adapters/rest_api_unit_of_work.py

@@ -0,0 +1,105 @@
+"""Contains the REST API Unit of Work implementation."""
+
+from typing import Any, TypeVar
+
+import requests
+
+from alpha.repositories.models.repository_model import RepositoryModel
+
+
+UOW = TypeVar("UOW", bound="RestApiUnitOfWork")
+
+
+class RestApiUnitOfWork:
+    """Unit of Work implementation for REST API interactions."""
+
+    def __init__(
+        self,
+        repos: list[RepositoryModel[Any]],
+        session: requests.sessions.Session | None = None,
+    ) -> None:
+        """Initialize the Unit of Work with repositories.
+
+        Parameters
+        ----------
+        repos : list[RepositoryModel]
+            The list of repository models to use.
+        session : requests.sessions.Session | None
+            The requests session (or compatible HTTP client, e.g., httpx) to
+            use for context management, by default None
+
+        Raises
+        ------
+        TypeError
+            If any repository does not implement its specified interface.
+        """
+        self._repositories = repos
+        self._session = session
+
+    def __enter__(self: UOW) -> UOW:
+        """Enter the REST API Unit of Work context.
+        Initializes a :class:`requests.sessions.Session` if one was not
+        provided and attaches the configured repositories as attributes on the
+        unit of work instance. Each repository is constructed using the shared
+        session and its associated configuration, and optionally validated
+        against a declared interface.
+
+        Returns
+        -------
+        UOW
+            The configured :class:`RestApiUnitOfWork` instance to be used
+            within the context manager.
+        """
+        self._session = self._session or requests.sessions.Session()
+
+        for repo in self._repositories:
+            name: str = repo.name
+            interface: Any = repo.interface
+            additional_config: dict[str, Any] = dict(
+                repo.additional_config or {}
+            )
+
+            self.__setattr__(
+                name,
+                repo.repository(
+                    session=self._session,
+                    default_model=repo.default_model,
+                    **additional_config,
+                ),
+            )
+
+            if interface:
+                if not isinstance(getattr(self, name), interface):
+                    raise TypeError(f"Repository for {name} has no interface")
+
+        return self
+
+    def __exit__(self, *args: Any) -> None:
+        """Finalize the Unit of Work context."""
+        if self._session:
+            self._session.close()
+
+    def commit(self) -> None:
+        raise NotImplementedError("RestApiUnitOfWork does not support commit")
+
+    def flush(self) -> None:
+        raise NotImplementedError("RestApiUnitOfWork does not support flush")
+
+    def rollback(self) -> None:
+        raise NotImplementedError(
+            "RestApiUnitOfWork does not support rollback"
+        )
+
+    def refresh(self, obj: object) -> None:
+        raise NotImplementedError("RestApiUnitOfWork does not support refresh")
+
+    @property
+    def session(self) -> requests.sessions.Session | None:
+        """Get the current session.
+
+        Returns
+        -------
+        requests.sessions.Session | None
+            The current session used for API interactions.
+        """
+        return self._session

alpha/adapters/sqla_unit_of_work.py

@@ -14,7 +14,11 @@ UOW = TypeVar("UOW", bound="SqlAlchemyUnitOfWork")
 class SqlAlchemyUnitOfWork:
     """Unit of Work implementation for SQLAlchemy databases."""
 
-    def __init__(self, db: SqlDatabase, repos: list[RepositoryModel]) -> None:
+    def __init__(
+        self,
+        db: SqlDatabase,
+        repos: list[RepositoryModel[Any]],
+    ) -> None:
         """Initialize the Unit of Work with a database and repositories.
 
         Parameters
@@ -28,9 +32,6 @@ class SqlAlchemyUnitOfWork:
         ------
         TypeError
             If the provided database is not a valid SqlDatabase instance.
-        TypeError
-            If the provided repositories list is empty or contains invalid
-            models.
         """
         if not isinstance(db, SqlDatabase):  # type: ignore
             raise TypeError("No valid database provided")
@@ -55,17 +56,16 @@ class SqlAlchemyUnitOfWork:
         self._session = self._db.get_session()
 
         for repo in self._repositories:
-            session = self._session
-            model = repo.default_model
-
             name: str = repo.name
-            repository = repo.repository
             interface: Any = repo.interface
 
             self.__setattr__(
                 name,
-                repository(session=session, default_model=model),  # type: ignore
+                repo.repository(
+                    session=self._session, default_model=repo.default_model
+                ),
             )
+
             if interface:
                 if not isinstance(getattr(self, name), interface):
                     raise TypeError(f"Repository for {name} has no interface")

alpha/domain/models/group.py

@@ -0,0 +1,35 @@
+from dataclasses import dataclass
+from datetime import datetime, timezone
+from typing import Sequence, cast
+from uuid import UUID
+
+from alpha.domain.models.base_model import BaseDomainModel, DomainModel
+from alpha.domain.models.life_cycle_base import LifeCycleBase
+
+
+@dataclass(kw_only=True)
+class Group(LifeCycleBase, BaseDomainModel):
+    id: UUID | int | str | None = None
+    name: str | None = None
+    description: str | None = None
+    permissions: Sequence[str] | None = None
+    is_active: bool = True
+
+    def update(self, obj: DomainModel) -> DomainModel:
+        """Update the Group instance with data from another Group instance.
+
+        Parameters
+        ----------
+        obj
+            Group object to update from.
+        """
+        if not isinstance(obj, Group):
+            raise TypeError("Group.update expects a Group instance.")
+
+        self.name = obj.name
+        self.description = obj.description
+        self.permissions = obj.permissions
+        self.modified_at = datetime.now(tz=timezone.utc)
+        self.is_active = obj.is_active
+
+        return cast(DomainModel, self)

alpha/exceptions.py

@@ -19,6 +19,10 @@ class NotFoundException(ClientErrorException):
     """Equivalent to HTTP code 404"""
 
 
+class MethodNotAllowedException(ClientErrorException):
+    """Equivalent to HTTP code 405"""
+
+
 class NotAcceptableException(ClientErrorException):
     """Equivalent to HTTP code 406"""
 
@@ -55,11 +59,19 @@ class ServiceUnavailableException(ServerErrorException):
     """Equivalent to HTTP code 503"""
 
 
+class GatewayTimeoutException(ServerErrorException):
+    """Equivalent to HTTP code 504"""
+
+
 # General Exceptions
 class MissingConfigurationException(Exception):
     """Raised when a required configuration is missing."""
 
 
+class InvalidAttributeError(Exception):
+    """Raised when a required attribute is invalid."""
+
+
 class MissingDependencyException(Exception):
     """Raised when a required dependency is missing."""
 

alpha/factories/jwt_factory.py

@@ -19,6 +19,24 @@ class JWTFactory:
         issuer: str = "http://localhost",
         jwt_algorithm: str = "HS256",
     ) -> None:
+        """Initialize the JWTFactory.
+
+        Parameters
+        ----------
+        secret
+            The secret key used to sign the JWT.
+        lifetime_hours, optional
+            The lifetime of the JWT in hours, by default "12"
+        issuer, optional
+            The issuer of the JWT, by default "http://localhost"
+        jwt_algorithm, optional
+            The algorithm used to sign the JWT, by default "HS256"
+
+        Raises
+        ------
+        ValueError
+            If the secret value is empty.
+        """
         if not secret:
             raise ValueError("Secret value cannot be empty")
         if lifetime_hours is None:

alpha/handlers/templates/python-flask/controller.mustache

@@ -231,6 +231,7 @@ def {{operationId}}(
             status_message='{{message}}',
             data=result,
             {{#vendorExtensions.x-content-type}}data_type='{{vendorExtensions.x-content-type}}'{{/vendorExtensions.x-content-type}}
+            {{#vendorExtensions.x-alpha-cookie-support}}response_type='flask'{{/vendorExtensions.x-alpha-cookie-support}}
         )
         return response_object, status_code
         {{/returnType}}

alpha/interfaces/__init__.py

@@ -6,8 +6,11 @@ from alpha.interfaces.openapi_model import OpenAPIModel
 from alpha.interfaces.updateable import Updateable
 from alpha.interfaces.patchable import Patchable
 
-# import all database related interfaces
+# import all repository related interfaces
+from alpha.interfaces.api_repository import ApiRepository
 from alpha.interfaces.sql_repository import SqlRepository
+
+# import all database related interfaces
 from alpha.interfaces.sql_mapper import SqlMapper
 from alpha.interfaces.sql_database import SqlDatabase
 from alpha.interfaces.unit_of_work import UnitOfWork
@@ -30,6 +33,7 @@ __all__ = [
     "OpenAPIModel",
     "Updateable",
     "Patchable",
+    "ApiRepository",
     "SqlRepository",
     "SqlMapper",
     "SqlDatabase",