alpha-python 0.1.0__py3-none-any.whl

alpha/factories/response_factory.py

@@ -0,0 +1,186 @@
+"""Contains ResponseFactory class"""
+
+import json
+from dataclasses import MISSING, is_dataclass
+from enum import Enum
+from typing import Any, Iterable, get_args, get_origin
+
+from alpha import exceptions
+from alpha.encoder import JSONEncoder
+from alpha.interfaces.dataclass_instance import DataclassInstance
+from alpha.interfaces.openapi_model import OpenAPIModel
+from alpha.utils.is_attrs import is_attrs
+
+
+class ResponseFactory:
+    """Mapping a dataclass instance to an OpenAPI model class"""
+
+    def process(
+        self,
+        response: DataclassInstance | Iterable[DataclassInstance],
+        cls: OpenAPIModel | Iterable[OpenAPIModel],
+    ) -> object:
+        """Mapping a dataclass instance or a collection of instances to an
+        OpenAPI model
+
+        Parameters
+        ----------
+        response
+            DomainModel instance
+        cls
+            OpenAPI model class or an Iterable
+
+        Returns
+        -------
+            OpenAPI model instance or a list of instances
+
+        Raises
+        ------
+        exceptions.ClassMismatchException
+            The targeted object type is a list but the source object is not
+            iterable
+        Exception
+            Encountered unexpected exception
+        ValueError
+            Unable to instantiate a class of type OpenAPIModel without values.
+            Probably because there are required values which cannot be None
+        TypeError
+            cls value is not a valid OpenAPIModel type
+        """
+
+        cls_origin = get_origin(cls)
+
+        # When the source instance and target class are of an iterable type
+        if cls_origin in [list, tuple, set]:
+            if isinstance(response, Iterable):
+                arg = get_args(cls)[0]
+                return [
+                    self.process(response=obj, cls=arg) for obj in response
+                ]
+            if cls_origin != get_origin(response):
+                raise exceptions.ClassMismatchException(
+                    "The targeted object type is a list but the source object "
+                    "is not iterable"
+                )
+            raise Exception(
+                f"Encountered unexpected exception; cls_origin: {cls_origin}, "
+                + f"response: {response}"
+            )
+
+        attrs: dict[str, type]
+        # Check if the openapi_types variable is set as a class variable
+        if len(cls.openapi_types) > 0:  # type: ignore
+            attrs = getattr(cls, "openapi_types")
+        # Else try to instantiate the class and read the openapi_types value
+        else:
+            try:
+                cls_instance: Any = cls()  # type: ignore
+            except ValueError as e:
+                raise ValueError(
+                    "Unable to instantiate a class of type OpenAPIModel "
+                    "without values. Probably because there are required "
+                    f"values which cannot be None: '{e}'. A solution to "
+                    "this problem is to set the 'openapi_types' attribute "
+                    "as a class variable instead of setting it in the "
+                    "__init__ method"
+                )
+            error_msg = (
+                f"'{cls.__name__}' is not a "  # type: ignore
+                "valid OpenAPIModel type"
+            )
+            if not hasattr(cls_instance, "openapi_types"):
+                raise TypeError(error_msg)
+            attrs = getattr(cls_instance, "openapi_types")
+
+        # Process attrs through _attr_factory
+        params = {
+            attr_name: self._attr_factory(
+                attr_name=attr_name, attr_type=attr_type, response=response
+            )
+            for attr_name, attr_type in attrs.items()
+        }
+
+        return cls(**params)  # type: ignore
+
+    def _attr_factory(
+        self, attr_name: str, attr_type: type, response: object
+    ) -> Any:
+        """Handles the attributes of an object by returning the response value
+        in the correct form
+
+        Parameters
+        ----------
+        attr_name
+            The name of the attribute
+        attr_type
+            The type of the attribute. This can be
+        response
+            A dataclass instance or an list of instances
+
+        Returns
+        -------
+        Any
+            The value from the response object which corresponds to the
+            attr_name
+        """
+        response_value = self._attr_lookup(obj=response, attr_name=attr_name)
+
+        if isinstance(response_value, Enum):
+            return response_value.name
+
+        # These if statements are needed to achieve a certain behavior
+        if isinstance(attr_type, OpenAPIModel) or (
+            get_origin(attr_type) is list
+        ):
+            if get_origin(attr_type) is list:
+                first_item = get_args(attr_type)[0]
+                if not isinstance(first_item, OpenAPIModel):
+                    return response_value
+            return self.process(response=response_value, cls=attr_type)  # type: ignore
+        return response_value
+
+    def _attr_lookup(self, obj: object, attr_name: str) -> Any:
+        """Lookup the attributes value from an object. The object can be of a
+        random type, including a dataclass or a dictionary.
+
+        Parameters
+        ----------
+        obj
+            The source object
+        attr_name
+            Attribute name
+
+        Returns
+        -------
+            Any value which corresponds to the attributes name
+
+        Raises
+        ------
+        exceptions.MissingAttributeError
+            Raises in case the attribute is not found
+        """
+        if hasattr(obj, attr_name):
+            return getattr(obj, attr_name, None)
+
+        if is_dataclass(obj) or is_attrs(obj):
+            attrs = getattr(obj, "__match_args__", [])
+
+            for attr in attrs:
+                obj_attr = getattr(obj, attr, MISSING)
+
+                if attr == attr_name:
+                    return obj_attr
+
+                # Lookup nested attribute
+                if hasattr(obj_attr, attr_name):
+                    return getattr(obj_attr, attr_name)
+
+        if isinstance(obj, dict):
+            if attr_name in obj.keys():
+                value: Any = obj[attr_name]
+                return value
+
+        raise exceptions.MissingAttributeError(
+            f"'{attr_name}' can not be found in the response object:"
+            + f"{json.dumps(obj, cls=JSONEncoder)}"
+        )

alpha/factories/type_factories.py

@@ -0,0 +1,204 @@
+"""Contains these TypeFactory classes:
+- GenericTypeFactory
+- DatetimeTypeFactory
+- EnumTypeFactory
+- JsonPatchTypeFactory
+"""
+
+import datetime
+from typing import Any, Iterable
+
+import pandas as pd
+
+from alpha import exceptions
+from alpha.factories._type_conversion_matrix import TYPE_CONVERSION_MATRIX
+from alpha.interfaces.openapi_model import OpenAPIModel
+
+
+class GenericTypeFactory:
+    """An implementation of TypeFactory which is able if process objects of
+    type 'type'
+    """
+
+    def process(
+        self, key: str, value: Any, cls: type, **kwargs: dict[str, Any]
+    ) -> Any:
+        """Processing generic object types
+
+        Parameters
+        ----------
+        key
+            Keyword of the argument. Used for logging purposes
+        value
+            The value object
+        cls
+            The targeted class
+
+        Returns
+        -------
+            An instance of the targeted class
+
+        Raises
+        ------
+        exceptions.ObjectConversionNotSupported
+            When conversion of the value is not supported
+        exceptions.ObjectConversionError
+            When an error occured when trying to convert the value to a cls
+            instance
+        exceptions.ObjectConversionNotAllowed
+            When conversion of the value is not allowed
+        """
+        from_type: Any = type(value)
+
+        try:
+            allowed: bool = TYPE_CONVERSION_MATRIX[from_type][cls]
+        except KeyError as exc:
+            raise exceptions.ObjectConversionNotSupported(
+                "Unable to convert an object, because the source "
+                f" ({from_type.__name__}) or target ({cls.__name__}) type "
+                "is not supported"
+            ) from exc
+
+        if allowed:
+            try:
+                return cls(value)
+            except ValueError as exc:
+                raise exceptions.ObjectConversionError(
+                    f"Unable to convert a(n) {from_type.__name__} "
+                    f"to a(n) {cls.__name__}"  # type: ignore
+                ) from exc
+        raise exceptions.ObjectConversionNotAllowed(
+            f"Converting '{key}' which is a(n) {from_type.__name__} class"
+            f"to a(n) {str(cls.__name__)} is not allowed"  # type: ignore
+        )
+
+
+class DatetimeTypeFactory:
+    """An implementation of TypeFactory which is able if process objects of
+    type 'datetime'
+    """
+
+    def process(
+        self,
+        key: str,
+        value: datetime.datetime | datetime.date | str,
+        cls: type,
+        **kwargs: dict[str, Any],
+    ) -> datetime.datetime | datetime.date:
+        """Processing datetime object types
+
+        Parameters
+        ----------
+        key
+            Keyword of the argument. Not used in this class
+        value
+            A datetime instance or datetime formatted string
+        cls
+            A datetime class
+
+        Returns
+        -------
+            A datetime instance
+        """
+        if isinstance(value, cls):
+            return value  # type: ignore
+
+        day_first = True if kwargs.get("day_first", False) else False
+
+        date_time = pd.to_datetime(  # type: ignore
+            value, dayfirst=day_first
+        ).to_pydatetime()
+        if cls == datetime.date:
+            return date_time.date()
+        return date_time
+
+
+class EnumTypeFactory:
+    """An implementation of TypeFactory which is able if process objects of
+    type 'Enum'
+    """
+
+    def process(
+        self, key: str, value: Any, cls: Any, **kwargs: dict[str, Any]
+    ) -> Any:
+        """Creates Enum objects from either a Enum name or value
+
+        Parameters
+        ----------
+        key
+            Keyword of the argument
+        value
+            The argument
+        cls
+            The class of the corresponding parameter
+
+        Returns
+        -------
+        Enum
+            An Enum object
+
+        Raises
+        ------
+        AttributeError
+            Not a valid Enum name or value
+        """
+        try:
+            if not value:
+                try:
+                    return getattr(cls, "NONE")
+                except AttributeError:
+                    return None
+            if isinstance(value, str):
+                return getattr(cls, str(value).upper())
+            return cls(value)  # type: ignore
+        except AttributeError as exc:
+            raise AttributeError(
+                f"{value} is not a valid Enum name for the {key} attribute"
+            ) from exc
+
+
+class JsonPatchTypeFactory:
+    """An implementation of TypeFactory which is able if process objects of
+    type 'JsonPatch'
+    """
+
+    def process(
+        self, key: str, value: Any, cls: Any, **kwargs: dict[str, Any]
+    ) -> Any:
+        """Processing JsonPatch object types
+
+        Parameters
+        ----------
+        key
+            Keyword of the argument. Used for logging purposes
+        value
+            An iterable containing OpenAPIModel with 'op', 'path' and 'value'
+            attributes
+        cls
+            The targeted class, which should always be JsonPatch
+
+        Returns
+        -------
+            An instance of the targeted class
+
+        Raises
+        ------
+        AttributeError
+            - When value is not an iterable
+            - When value is an empty iterable
+            - When value does not contain OpenAPIModel instances
+        """
+        if not isinstance(value, Iterable):
+            raise AttributeError(f"The {key} attribute has to be an iterable")
+        if len(value) == 0:  # type: ignore
+            raise AttributeError(
+                f"The {key} attribute cannot be an empty iterable"
+            )
+        if isinstance(value[0], OpenAPIModel):  # type: ignore
+            patches: list[OpenAPIModel] = value  # type: ignore
+            return cls([patch.to_dict() for patch in patches])  # type: ignore
+        else:
+            raise AttributeError(
+                f"The {key} attribute has to be an iterable containing "
+                "OpenAPIModel objects of a JsonPatch type"
+            )

alpha/infra/database/sql_alchemy_database.py

@@ -0,0 +1,159 @@
+"""_summary_"""
+
+import sqlalchemy as sa
+from sqlalchemy.engine import Engine
+from sqlalchemy.orm import (
+    scoped_session,
+    sessionmaker,
+)
+from sqlalchemy.orm.session import Session
+
+from alpha.interfaces.sql_mapper import SqlMapper
+
+
+class SqlAlchemyDatabase:
+    """_summary_"""
+
+    def __init__(
+        self,
+        host: str = "",
+        port: int | None = None,
+        username: str = "",
+        password: str = "",
+        db_name: str = "",
+        db_type: str = "postgresql",
+        conn_str: str | None = None,
+        schema_name: str = "public",
+        create_schema: bool = True,
+        create_tables: bool = True,
+        pool_pre_ping: bool = False,
+        mapper: SqlMapper | None = None,
+    ) -> None:
+        """_summary_
+
+        Parameters
+        ----------
+        host : str, optional
+            _description_, by default ""
+        port : int | None, optional
+            _description_, by default None
+        username : str, optional
+            _description_, by default ""
+        password : str, optional
+            _description_, by default ""
+        db_name : str, optional
+            _description_, by default ""
+        db_type : str, optional
+            _description_, by default "postgresql"
+        conn_str : str | None, optional
+            _description_, by default None
+        schema_name : str, optional
+            _description_, by default "public"
+        create_schema : bool, optional
+            _description_, by default True
+        create_tables : bool, optional
+            _description_, by default True
+        mapper : interfaces.SqlMapper | None, optional
+            _description_, by default None
+        """
+        self._host = host
+        self._port = port
+        self._username = username
+        self._password = password
+        self._db_name = db_name
+        self._db_type = db_type
+        self._schema_name = schema_name
+        self._mapper = mapper
+
+        if conn_str is None:
+            conn_str = (
+                f"{self._db_type}://{self._username}:"
+                + f"{self._password}@{self._host}:{self._port}/{self._db_name}"
+            )
+        self._connection_string = conn_str
+
+        self._engine = sa.create_engine(
+            self._connection_string, pool_pre_ping=pool_pre_ping
+        )
+        self._session_factory = scoped_session(
+            sessionmaker(
+                bind=self._engine, autocommit=False, expire_on_commit=False
+            )
+        )
+
+        if self._mapper:
+            if not self._mapper.started:
+                self._mapper.start_mapping()
+            if create_tables:
+                self.create_tables(self._mapper.metadata)
+
+        if hasattr(self._engine.dialect, "has_schema") & create_schema:
+            self._create_schema(self._engine, self._schema_name)
+
+    def get_session(self) -> Session:
+        """_summary_
+
+        Returns
+        -------
+        Session
+            _description_
+        """
+        return self._session_factory()
+
+    def engine(self) -> Engine:
+        """_summary_
+
+        Returns
+        -------
+        Engine
+            _description_
+        """
+        return self._engine
+
+    def create_tables(
+        self, metadata: sa.MetaData, tables: list[sa.Table] | None = None
+    ) -> None:
+        """_summary_
+
+        Parameters
+        ----------
+        metadata : sa.MetaData
+            _description_
+        tables : list[sa.Table] | None, optional
+            _description_, by default None
+        """
+        metadata.create_all(self._engine, tables=tables)
+
+    def drop_tables(
+        self, metadata: sa.MetaData, tables: list[sa.Table] | None = None
+    ) -> None:
+        """_summary_
+
+        Parameters
+        ----------
+        metadata : sa.MetaData
+            _description_
+        tables : list[sa.Table] | None, optional
+            _description_, by default None
+        """
+        metadata.drop_all(self._engine, tables=tables)
+
+    def _create_schema(self, engine: Engine, schema_name: str) -> None:
+        """_summary_
+
+        Parameters
+        ----------
+        engine : Engine
+            _description_
+        schema_name : str
+            _description_
+        """
+        major, *_ = sa.__version__.split(".")
+
+        if int(major) < 2:
+            if not engine.dialect.has_schema(engine, schema_name):  # type: ignore
+                getattr(engine, "execute")(sa.schema.CreateSchema(schema_name))
+        else:
+            with engine.begin() as connection:
+                if not sa.inspect(engine).has_schema(schema_name):
+                    connection.execute(sa.schema.CreateSchema(schema_name))

alpha/infra/database/sql_alchemy_view.py

@@ -0,0 +1,48 @@
+from sqlalchemy.schema import DDLElement
+from sqlalchemy import MetaData, event, inspect, table
+from sqlalchemy.ext import compiler
+
+
+class CreateView(DDLElement):
+    def __init__(self, name, selectable):
+        self.name = name
+        self.selectable = selectable
+
+
+class DropView(DDLElement):
+    def __init__(self, name):
+        self.name = name
+
+
+@compiler.compiles(CreateView)
+def _create_view(element, compiler, **kw):
+    return "CREATE OR REPLACE VIEW %s AS %s" % (
+        element.name,
+        compiler.sql_compiler.process(element.selectable, literal_binds=True),
+    )
+
+
+@compiler.compiles(DropView)
+def _drop_view(element, compiler, **kw):
+    return "DROP VIEW %s" % (element.name)
+
+
+class View:
+    def __init__(self, name: str, metadata: MetaData, selectable):
+        t = table(name)
+
+        t._columns._populate_separate_keys(
+            col._make_proxy(t) for col in selectable.selected_columns
+        )
+
+        event.listen(metadata, "after_create", CreateView(name, selectable))
+        event.listen(
+            metadata, "before_drop", DropView(name).execute_if(callable_=self.view_exists)  # type: ignore
+        )
+        return t
+
+    def view_exists(self, ddl, target, connection, **kw):
+        return ddl.name in inspect(connection).get_view_names()
+
+    def view_doesnt_exist(self, ddl, target, connection, **kw):
+        return not self.view_exists(ddl, target, connection, **kw)

alpha/infra/models/filter_operators.py

@@ -0,0 +1,98 @@
+"""Contains these FilterOperator classes:
+- And
+- Or
+"""
+
+from typing import Any, Callable, Iterable
+
+from sqlalchemy.orm import Query
+from sqlalchemy.sql.expression import ColumnElement, and_, or_
+
+from alpha.infra.models.search_filter import SearchFilter
+
+
+class FilterOperator:
+    """Base class for filter operators which can be used to specify the
+    search query
+    """
+
+    def __init__(self, *search_filters: SearchFilter):
+        """Instantiate the filter operator by storing
+        the search filter objects
+        """
+        self.search_filters: Iterable[SearchFilter | FilterOperator] = (
+            search_filters
+        )
+
+    @property
+    def filter_operator(
+        self,
+    ) -> Callable[[ColumnElement[bool]], ColumnElement[bool]]:
+        """Returns a filter operator
+
+        Returns
+        -------
+            filter operator
+
+        Raises
+        ------
+        NotImplementedError
+            When called directly
+        """
+        raise NotImplementedError(
+            "The FilterOperator class cannot be used directly. "
+            "Use the And or Or classes instead."
+        )
+
+    def filter(self, query: Query[Any]) -> Query[Any]:
+        """Applies the search filters on the query by using the filter operator
+
+        Parameters
+        ----------
+        query
+            Query object
+
+        Returns
+        -------
+            Query object
+        """
+        filters = [f.filter_statement for f in self.search_filters]  # type: ignore
+        return query.filter(self.filter_operator(*filters))  # type: ignore
+
+
+class And(FilterOperator):
+    """FilterOperator which can be used to explicitly specify an 'and'
+    statement to apply behaviore of SearchFilter objects which is comparable
+    to AND in SQL.
+    """
+
+    @property
+    def filter_operator(
+        self,
+    ) -> Callable[[ColumnElement[bool]], ColumnElement[bool]]:
+        """Returns the 'and' filter operator
+
+        Returns
+        -------
+            'and' filter operator
+        """
+        return and_
+
+
+class Or(FilterOperator):
+    """FilterOperator which can be used to explicitly specify an 'or'
+    statement to apply behaviore of SearchFilter objects which is comparable
+    to OR in SQL.
+    """
+
+    @property
+    def filter_operator(
+        self,
+    ) -> Callable[[ColumnElement[bool]], ColumnElement[bool]]:
+        """Returns the 'or' filter operator
+
+        Returns
+        -------
+            'or' filter operator
+        """
+        return or_