alpha-python 0.1.0__py3-none-any.whl

alpha/adapters/sqla_unit_of_work.py

@@ -0,0 +1,120 @@
+"""Contains the SQLAlchemy Unit of Work implementation."""
+
+from typing import Any, TypeVar
+
+from sqlalchemy.orm.session import Session
+
+from alpha import exceptions
+from alpha.interfaces.sql_database import SqlDatabase
+from alpha.repositories.models.repository_model import RepositoryModel
+
+UOW = TypeVar("UOW", bound="SqlAlchemyUnitOfWork")
+
+
+class SqlAlchemyUnitOfWork:
+    """Unit of Work implementation for SQLAlchemy databases."""
+
+    def __init__(self, db: SqlDatabase, repos: list[RepositoryModel]) -> None:
+        """Initialize the Unit of Work with a database and repositories.
+
+        Parameters
+        ----------
+        db : SqlDatabase
+            The database instance to use.
+        repos : list[RepositoryModel]
+            The list of repository models to use.
+
+        Raises
+        ------
+        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")
+
+        self._db = db
+        self._repositories = repos
+        self._session: Session | None = None
+
+    def __enter__(self: UOW) -> UOW:
+        """Initialize the Unit of Work context.
+
+        Returns
+        -------
+            The Unit of Work instance.
+
+        Raises
+        ------
+        TypeError
+            If the provided repositories list is empty or contains invalid
+            models.
+        """
+        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
+            )
+            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 not self._session:
+            raise exceptions.DatabaseSessionError(
+                "No active database session is defined"
+            )
+        self._session.close()
+        self.rollback()
+        self._session = None  # type: ignore
+
+    def commit(self) -> None:
+        """Commit the current transaction."""
+        if not self._session:
+            raise exceptions.DatabaseSessionError(
+                "No active database session is defined"
+            )
+        self._session.commit()
+
+    def flush(self) -> None:
+        """Flush the current transaction."""
+        if not self._session:
+            raise exceptions.DatabaseSessionError(
+                "No active database session is defined"
+            )
+        self._session.flush()
+
+    def rollback(self) -> None:
+        """Rollback the current transaction."""
+        if not self._session:
+            raise exceptions.DatabaseSessionError(
+                "No active database session is defined"
+            )
+        self._session.rollback()
+
+    def refresh(self, obj: object) -> None:
+        """Refresh the state of a given object."""
+        if not self._session:
+            raise exceptions.DatabaseSessionError(
+                "No active database session is defined"
+            )
+        self._session.refresh(obj)
+
+    @property
+    def session(self) -> Session | None:
+        """Get the current database session."""
+        return self._session

alpha/domain/models/base_model.py

@@ -0,0 +1,25 @@
+from dataclasses import dataclass
+from typing import Any, TypeVar
+
+DomainModel = TypeVar("DomainModel", bound="BaseDomainModel")
+DomainModelCovariant = TypeVar(
+    "DomainModelCovariant", bound="BaseDomainModel", covariant=True
+)
+DomainModelContravariant = TypeVar(
+    "DomainModelContravariant", bound="BaseDomainModel", contravariant=True
+)
+
+
+@dataclass
+class BaseDomainModel:
+    def to_dict(self) -> dict[str, Any]:
+        obj: dict[str, Any] = {}
+        for attr in self.__dataclass_fields__.keys():
+            if not attr.startswith("_"):
+                obj[attr] = getattr(self, attr)
+            if attr == "_id":
+                obj[attr] = str(getattr(self, attr))
+        return obj
+
+    def update(self, obj: DomainModel) -> DomainModel:
+        raise NotImplementedError("Subclasses must implement the update method")

alpha/encoder.py

@@ -0,0 +1,62 @@
+import json
+from dataclasses import asdict, is_dataclass
+from datetime import date, datetime, time
+from enum import Enum
+from json import encoder
+from typing import Any
+from uuid import UUID
+
+import numpy as np
+import pandas as pd
+import six
+
+from alpha.interfaces.openapi_model import OpenAPIModel
+
+
+class JSONEncoder(encoder.JSONEncoder):
+    include_nulls = False
+
+    def default(self, o: Any) -> Any:
+        if isinstance(o, list):
+            return [self.default(item) for item in o]  # type: ignore
+        if isinstance(o, OpenAPIModel):
+            dikt: dict[str, Any] = {}
+            for attr, _ in six.iteritems(o.openapi_types):
+                value = getattr(o, attr)
+                if value is None and not self.include_nulls:
+                    continue
+                attr = o.attribute_map[attr]
+                dikt[attr] = value
+            return dikt
+        if hasattr(o, "to_dict"):
+            return o.to_dict()
+        if hasattr(o, "to_list"):
+            return o.to_list()
+        if isinstance(o, set):
+            return list(o)  # type: ignore
+        if isinstance(o, Enum):
+            return o.name
+        if isinstance(o, UUID):
+            return str(o)
+        if isinstance(o, np.int64):  # type: ignore
+            return int(o)
+        if isinstance(o, np.float32):  # type: ignore
+            return float(o)
+        if isinstance(o, pd.Timestamp):
+            return o.isoformat()
+        if isinstance(o, datetime):
+            return o.isoformat()
+        if isinstance(o, date):
+            return o.isoformat()
+        if isinstance(o, time):
+            return o.isoformat()
+        if is_dataclass(o):
+            if isinstance(o, type):
+                cls = getattr(o, "__class__")
+                return cls.__name__
+            return asdict(o)
+
+        try:
+            return json.JSONEncoder.default(self, o)
+        except Exception:
+            return None

alpha/exceptions.py

@@ -0,0 +1,99 @@
+# HTTP Exceptions
+class BadRequestException(Exception):
+    """Equivalent to HTTP code 400"""
+
+
+class UnauthorizedException(Exception):
+    """Equivalent to HTTP code 401"""
+
+
+class ForbiddenException(Exception):
+    """Equivalent to HTTP code 403"""
+
+
+class NotFoundException(Exception):
+    """Equivalent to HTTP code 404"""
+
+
+class NotAcceptableException(Exception):
+    """Equivalent to HTTP code 406"""
+
+
+class ConflictException(Exception):
+    """Equivalent to HTTP code 409"""
+
+
+class PayloadTooLargeException(Exception):
+    """Equivalent to HTTP code 413"""
+
+
+class UnprocessableContentException(Exception):
+    """Equivalent to HTTP code 422"""
+
+
+class ErrorException(Exception): ...
+
+
+class InternalServerErrorException(ErrorException):
+    """Equivalent to HTTP code 500"""
+
+
+class NotImplementedException(ErrorException):
+    """Equivalent to HTTP code 501"""
+
+
+class BadGatewayException(ErrorException):
+    """Equivalent to HTTP code 502"""
+
+
+class ServiceUnavailableException(ErrorException):
+    """Equivalent to HTTP code 503"""
+
+
+## Common exceptions
+class DatabaseMapperError(Exception): ...
+
+
+class DatabaseSessionError(InternalServerErrorException): ...
+
+
+class InstrumentedAttributeMissing(Exception): ...
+
+
+class AlreadyExistsException(ForbiddenException): ...
+
+
+class TypingFactoryException(Exception): ...
+
+
+class ModelClassFactoryException(Exception): ...
+
+
+class DefaultFactoryException(Exception): ...
+
+
+class ObjectConversionNotSupported(Exception): ...
+
+
+class ObjectConversionNotAllowed(Exception): ...
+
+
+class ObjectConversionError(Exception): ...
+
+
+class UnionArgumentError(Exception): ...
+
+
+class MixedArgumentTypesError(Exception): ...
+
+
+class MissingAttributeError(Exception): ...
+
+
+class ClassMismatchException(Exception): ...
+
+
+class LoggingHandlerException(Exception): ...
+
+
+class ClassFactoryException(Exception): ...

alpha/factories/_type_conversion_matrix.py

@@ -0,0 +1,233 @@
+"""Contains the TYPE_CONVERSION_MATRIX constant which can be used to determine
+if it is allowed to cast an object to a different type.
+"""
+
+import datetime
+import uuid
+
+TYPE_CONVERSION_MATRIX: dict[type, dict[type, bool]] = {
+    str: {
+        str: True,
+        complex: True,
+        int: True,
+        float: True,
+        bytes: True,
+        bytearray: True,
+        list: True,
+        dict: False,
+        set: True,
+        tuple: True,
+        bool: True,
+        datetime.datetime: True,
+        datetime.date: True,
+        uuid.UUID: True,
+    },
+    complex: {
+        str: True,
+        complex: True,
+        int: False,
+        float: False,
+        bytes: False,
+        bytearray: False,
+        list: False,
+        dict: False,
+        set: False,
+        tuple: False,
+        bool: True,
+        datetime.datetime: False,
+        datetime.date: False,
+        uuid.UUID: False,
+    },
+    int: {
+        str: True,
+        complex: True,
+        int: True,
+        float: True,
+        bytes: True,
+        bytearray: True,
+        list: False,
+        dict: False,
+        set: False,
+        tuple: False,
+        bool: True,
+        datetime.datetime: True,
+        datetime.date: True,
+        uuid.UUID: False,
+    },
+    float: {
+        str: True,
+        complex: True,
+        int: True,
+        float: True,
+        bytes: False,
+        bytearray: False,
+        list: False,
+        dict: False,
+        set: False,
+        tuple: False,
+        bool: True,
+        datetime.datetime: False,
+        datetime.date: False,
+        uuid.UUID: False,
+    },
+    bytes: {
+        str: False,
+        complex: False,
+        int: False,
+        float: False,
+        bytes: True,
+        bytearray: True,
+        list: False,
+        dict: False,
+        set: False,
+        tuple: False,
+        bool: True,
+        datetime.datetime: False,
+        datetime.date: False,
+        uuid.UUID: False,
+    },
+    bytearray: {
+        str: False,
+        complex: False,
+        int: False,
+        float: False,
+        bytes: True,
+        bytearray: True,
+        list: False,
+        dict: False,
+        set: False,
+        tuple: False,
+        bool: True,
+        datetime.datetime: False,
+        datetime.date: False,
+        uuid.UUID: False,
+    },
+    list: {
+        str: True,
+        complex: False,
+        int: False,
+        float: False,
+        bytes: True,
+        bytearray: True,
+        list: True,
+        dict: False,
+        set: True,
+        tuple: True,
+        bool: True,
+        datetime.datetime: False,
+        datetime.date: False,
+        uuid.UUID: False,
+    },
+    dict: {
+        str: True,
+        complex: False,
+        int: False,
+        float: False,
+        bytes: False,
+        bytearray: False,
+        list: True,
+        dict: True,
+        set: True,
+        tuple: True,
+        bool: True,
+        datetime.datetime: False,
+        datetime.date: False,
+        uuid.UUID: False,
+    },
+    set: {
+        str: True,
+        complex: False,
+        int: False,
+        float: False,
+        bytes: True,
+        bytearray: True,
+        list: True,
+        dict: False,
+        set: True,
+        tuple: True,
+        bool: True,
+        datetime.datetime: False,
+        datetime.date: False,
+        uuid.UUID: False,
+    },
+    tuple: {
+        str: True,
+        complex: False,
+        int: False,
+        float: False,
+        bytes: True,
+        bytearray: True,
+        list: True,
+        dict: False,
+        set: True,
+        tuple: True,
+        bool: True,
+        datetime.datetime: False,
+        datetime.date: False,
+        uuid.UUID: False,
+    },
+    bool: {
+        str: True,
+        complex: True,
+        int: True,
+        float: True,
+        bytes: True,
+        bytearray: True,
+        list: False,
+        dict: False,
+        set: False,
+        tuple: False,
+        bool: True,
+        datetime.datetime: False,
+        datetime.date: False,
+        uuid.UUID: False,
+    },
+    datetime.datetime: {
+        str: True,
+        complex: False,
+        int: False,
+        float: False,
+        bytes: False,
+        bytearray: False,
+        list: False,
+        dict: False,
+        set: False,
+        tuple: False,
+        bool: True,
+        datetime.datetime: True,
+        datetime.date: True,
+        uuid.UUID: False,
+    },
+    datetime.date: {
+        str: True,
+        complex: False,
+        int: False,
+        float: False,
+        bytes: False,
+        bytearray: False,
+        list: False,
+        dict: False,
+        set: False,
+        tuple: False,
+        bool: True,
+        datetime.datetime: True,
+        datetime.date: True,
+        uuid.UUID: False,
+    },
+    uuid.UUID: {
+        str: True,
+        complex: False,
+        int: True,
+        float: False,
+        bytes: False,
+        bytearray: False,
+        list: False,
+        dict: False,
+        set: False,
+        tuple: False,
+        bool: False,
+        datetime.datetime: False,
+        datetime.date: False,
+        uuid.UUID: False,
+    },
+}

alpha/factories/_type_mapping.py

@@ -0,0 +1,29 @@
+"""Contains the TYPES constant to determine which TypeFactory can be used to
+process a certain object type
+"""
+
+import datetime
+import uuid
+
+from alpha.factories.type_factories import (
+    DatetimeTypeFactory,
+    GenericTypeFactory,
+)
+from alpha.interfaces.factories import TypeFactory
+
+TYPES: dict[type, type[TypeFactory]] = {
+    str: GenericTypeFactory,
+    complex: GenericTypeFactory,
+    int: GenericTypeFactory,
+    float: GenericTypeFactory,
+    bytes: GenericTypeFactory,
+    bytearray: GenericTypeFactory,
+    list: GenericTypeFactory,
+    dict: GenericTypeFactory,
+    set: GenericTypeFactory,
+    tuple: GenericTypeFactory,
+    bool: GenericTypeFactory,
+    uuid.UUID: GenericTypeFactory,
+    datetime.datetime: DatetimeTypeFactory,
+    datetime.date: DatetimeTypeFactory,
+}