alpha-python 0.1.0__py3-none-any.whl

alpha/factories/field_iterator.py

@@ -0,0 +1,188 @@
+"""Contains Field & FieldIterator class"""
+
+import dataclasses
+import attrs
+from typing import Any
+
+from alpha.interfaces.attrs_instance import AttrsInstance
+from alpha.interfaces.dataclass_instance import DataclassInstance
+from alpha.utils.is_attrs import is_attrs
+
+
+class Field:
+    """An object which is used in ModelClassFactory & ClassFactory instances
+    to share specific values about class attributes
+    """
+
+    def __init__(
+        self,
+        init: bool,
+        name: str,
+        type_: Any,
+        default: Any,
+        default_factory: Any = None,
+    ) -> None:
+        """Initialize a Field object
+
+        Parameters
+        ----------
+        init
+            init value
+        name
+            name value
+        type_
+            type value. Can be an actual type or the string name of the type
+            in which case the value will be evaluated to extract the type
+        default
+            default value
+        default_factory, optional
+            default value if present, by default None
+        """
+        self.init = init
+        self.name = name
+        self.default = default
+        self.default_factory = default_factory
+
+        if isinstance(type_, str):
+            try:
+                self.type = eval(type_)
+            except NameError as exc:
+                raise NameError(
+                    f"Unable to evaluate '{type_}' as a type: {exc}.\n"
+                    "A string value is found as type annotation of a class "
+                    "attribute. This behavure is probably caused by importing "
+                    "__future__.annotations in the module of a data class. "
+                    "This behavure is also described in PEP563 "
+                    "(https://peps.python.org/pep-0563/). Try not importing "
+                    "__future__.annotations."
+                )
+        else:
+            self.type = type_
+
+    def __repr__(self) -> str:
+        """Creates a string representation of the object
+
+        Returns
+        -------
+            string representation of the object
+        """
+        return (
+            "Field("
+            f"name={self.name!r},"
+            f"type={self.type!r},"
+            f"default={self.default!r},"
+            f"default_factory={self.default_factory!r},"
+            f"init={self.init!r}"
+            ")"
+        )
+
+    @classmethod
+    def from_dataclass(cls, obj: dataclasses.Field[Any]) -> "Field":
+        """Create a Field object from a dataclass Field
+
+        Parameters
+        ----------
+        obj
+            dataclass Field
+
+        Returns
+        -------
+            Field object
+        """
+        return cls(
+            init=obj.init,
+            name=obj.name,
+            type_=obj.type,
+            default=obj.default,
+            default_factory=obj.default_factory,
+        )
+
+    @classmethod
+    def from_attrs(cls, obj: attrs.Attribute) -> "Field":  # type: ignore
+        """Create a Field object from a attrs Attribute
+
+        Parameters
+        ----------
+        obj
+            attrs Attribute
+
+        Returns
+        -------
+            Field object
+        """
+        return cls(
+            init=obj.init,
+            name=obj.name,
+            type_=obj.type,  # type: ignore
+            default=obj.default,  # type: ignore
+        )
+
+
+class FieldIterator:
+    """A collection of Field objects"""
+
+    def __init__(self, obj: DataclassInstance | AttrsInstance) -> None:
+        """Initialize a FieldIterator by determining the class type of the
+        obj argument
+
+        Parameters
+        ----------
+        obj
+            Class of the dataclass or attrs type
+
+        Raises
+        ------
+        TypeError
+            When the obj argument is of an unsupported type
+        """
+        self._index = 0
+
+        try:
+            if dataclasses.is_dataclass(obj):
+                self._fields = [
+                    Field.from_dataclass(field)
+                    for field in dataclasses.fields(obj)
+                ]
+            elif is_attrs(obj):
+                self._fields = [
+                    Field.from_attrs(field)  # type: ignore
+                    for field in attrs.fields(obj)  # type: ignore
+                ]
+            else:
+                raise TypeError(
+                    "Incorrect object type. Only a dataclass- or "
+                    "attrs class is supported"
+                )
+        except NameError as exc:
+            raise NameError(
+                "An error occured while evaluating an attribute of the "
+                f"{obj.__name__} class. {exc}"  # type: ignore
+            )
+
+    def __iter__(self) -> "FieldIterator":
+        """Iter method
+
+        Returns
+        -------
+            This object
+        """
+        return self
+
+    def __next__(self) -> Field:
+        """Next method
+
+        Returns
+        -------
+            Next item in the collection
+
+        Raises
+        ------
+        StopIteration
+            Collection out of range
+        """
+        if self._index < len(self._fields):
+            item = self._fields[self._index]
+            self._index += 1
+            return item
+        else:
+            raise StopIteration

alpha/factories/logging_handler_factory.py

@@ -0,0 +1,86 @@
+"""Contains LoggerHandlerFactory class"""
+
+from typing import Any
+
+from alpha import exceptions
+
+
+class LoggingHandlerFactory:
+    """For creating a valid logging handler from a dict object.
+
+    Supported handlers:
+        - logging.StreamHandler
+        - logging.FileHandler
+        - logging.handlers.RotatingFileHandler
+        - logging.handlers.TimedRotatingFileHandler
+        - logging.handlers.WatchedFileHandler
+    """
+
+    @classmethod
+    def parse(cls, handler: dict[str, Any]) -> dict[str, Any]:
+        """Parse a logging handler object.
+
+        Parameters
+        ----------
+        handler
+            A dictionary with at least the 'type' key. All other keys depend on
+            the handler type/class. Use the 'logging.handlers' section of the
+            python docs to determine which keys can be used for each handler
+            type/class.
+
+        Returns
+        -------
+            A handler dictionary which can be used in the handlers section of a
+            logging.config.dictConfig compatible dictionary.
+
+        Raises
+        ------
+        exceptions.LoggingHandlerException
+            - When the 'type' value of the handler is missing or None
+            - When a 'FileHandler' is missing the 'filename' value
+        """
+        type_: str | None = handler.get("type", None)
+        if type_ is None:
+            raise exceptions.LoggingHandlerException(
+                "the logger handler is missing a type attribute"
+            )
+        *_, class_name = type_.split(".")
+
+        obj: dict[str, Any] = {
+            "class": type_,
+            "level": handler.get("level", "DEBUG").upper(),
+            "formatter": handler.get("formatter", "default"),
+        }
+
+        if class_name == "StreamHandler":
+            obj.update({"stream": handler.get("stream", "ext://sys.stderr")})
+        if "FileHandler" in class_name:
+            _filename = handler.get("filename")
+            if not _filename:
+                raise exceptions.LoggingHandlerException(
+                    "the logger handler is missing a filename attribute"
+                )
+            obj.update(
+                {
+                    "filename": _filename,
+                    "encoding": handler.get("encoding"),
+                    "delay": handler.get("delay", False),
+                    "errors": handler.get("errors"),
+                }
+            )
+        if "RotatingFileHandler" in class_name:
+            obj.update({"backupCount": handler.get("backupCount", 0)})
+        if class_name == "RotatingFileHandler":
+            obj.update({"maxBytes": handler.get("maxBytes", 0)})
+        if class_name == "TimedRotatingFileHandler":
+            obj.update(
+                {
+                    "when": handler.get("when", "h"),
+                    "interval": handler.get("interval", 1),
+                    "utc": handler.get("utc", False),
+                    "atTime": handler.get("atTime"),
+                }
+            )
+        else:
+            obj.update({"mode": handler.get("mode", "a")})
+        return obj

alpha/factories/model_class_factory.py

@@ -0,0 +1,176 @@
+"""Contains ModelClassFactory class"""
+
+import enum
+import types
+import typing
+from typing import Any
+
+from alpha import exceptions
+from alpha.factories.class_factories import (
+    AnyClassFactory,
+    DataclassClassFactory,
+    DictClassFactory,
+    EnumClassFactory,
+    GenericAliasClassFactory,
+    IterableClassFactory,
+    NativeClassFactory,
+    UnionClassFactory,
+)
+from alpha.factories.default_field_factory import DefaultFieldFactory
+from alpha.factories.field_iterator import FieldIterator
+from alpha.factories.models.factory_classes import FactoryClasses
+from alpha.factories.type_factories import (
+    GenericTypeFactory,
+    DatetimeTypeFactory,
+    EnumTypeFactory,
+    JsonPatchTypeFactory,
+)
+from alpha.interfaces.attrs_instance import AttrsInstance
+from alpha.interfaces.dataclass_instance import DataclassInstance
+from alpha.interfaces.factories import (
+    ClassFactory,
+    TypeFactory,
+)
+from alpha.interfaces.openapi_model import OpenAPIModel
+from alpha.utils.version_check import minor_version_gte
+
+
+CLASS_FACTORIES: dict[str, ClassFactory] = {
+    "iterable": IterableClassFactory(),
+    "dict": DictClassFactory(),
+    "dataclass": DataclassClassFactory(),
+    "generic_alias": GenericAliasClassFactory(),
+    "union": UnionClassFactory(),
+    "native": NativeClassFactory(),
+    "enum": EnumClassFactory(),
+    "any": AnyClassFactory(),
+}
+
+
+TYPE_FACTORIES: dict[str, TypeFactory] = {
+    "generic": GenericTypeFactory(),
+    "datetime": DatetimeTypeFactory(),
+    "enum": EnumTypeFactory(),
+    "json_patch": JsonPatchTypeFactory(),
+}
+
+
+TYPING_CLASSES: dict[object, ClassFactory] = {
+    getattr(typing, "_GenericAlias"): CLASS_FACTORIES["generic_alias"],
+    getattr(typing, "_UnionGenericAlias"): CLASS_FACTORIES["union"],
+    getattr(typing, "_SpecialForm"): CLASS_FACTORIES["any"],
+    enum.EnumMeta: CLASS_FACTORIES["enum"],
+    type: CLASS_FACTORIES["native"],
+}
+
+if minor_version_gte(10):
+    TYPING_CLASSES.update(
+        {
+            getattr(types, "UnionType"): CLASS_FACTORIES["union"],
+        }
+    )
+
+if minor_version_gte(11):
+    TYPING_CLASSES.update(
+        {
+            getattr(typing, "_AnyMeta"): CLASS_FACTORIES["any"],
+            getattr(types, "GenericAlias"): CLASS_FACTORIES["generic_alias"],
+            getattr(enum, "EnumType"): CLASS_FACTORIES["enum"],
+        }
+    )
+
+
+FACTORY_CLASSES = FactoryClasses(
+    class_factories=CLASS_FACTORIES,
+    type_factories=TYPE_FACTORIES,
+    default_factory=DefaultFieldFactory(),
+    model_class_factory=None,
+)
+
+
+class ModelClassFactory:
+    """The ModelClassFactory can be used to cast OpenAPIModel objects to
+    instances of dataclass or attrs classes
+    """
+
+    def __init__(
+        self,
+        typing_classes: dict[object, ClassFactory] = TYPING_CLASSES,
+        factory_classes: FactoryClasses = FACTORY_CLASSES,
+    ) -> None:
+        """Initializing and setting the self.typing_classes class variable
+        which contains typing classes and references to the corresponding
+        factory classes. The set of typing classes depend on the python minor
+        version.
+
+        Parameters
+        ----------
+        typing_classes, optional
+            A collection of class types, by default TYPING_CLASSES
+        factory_classes, optional
+            An instance of FactoryClasses which acts as a toolbox of Factory
+            classes, by default FACTORY_CLASSES
+        """
+        self.typing_classes = typing_classes
+        self.factory_classes = factory_classes
+
+        if self.factory_classes.model_class_factory is None:
+            self.factory_classes.model_class_factory = self
+
+    def process(
+        self,
+        obj: OpenAPIModel,
+        cls: DataclassInstance | AttrsInstance | Any,
+    ) -> DataclassInstance | AttrsInstance | None:
+        """Creating a new cls instance from a OpenAPIModel object. This class
+        uses a compatibele ClassFactory, from the self.typing_classes
+        collection, per cls field to process each value.
+
+        Parameters
+        ----------
+        obj
+            OpenAPIModel object
+        cls
+            A dataclass or attrs class to create a new instance
+
+        Returns
+        -------
+            Dataclass or attrs instance
+
+        Raises
+        ------
+        exceptions.ModelClassFactoryException
+            When cls is not a dataclass or attrs decorated class
+        KeyError
+            When the class type is not present in self.typing_classes
+        """
+
+        try:
+            fields = FieldIterator(cls)
+        except TypeError:
+
+            raise exceptions.ModelClassFactoryException(
+                "cls argument has to be a dataclass or attrs decorated class"
+            )
+
+        params: dict[str, Any] = {}
+
+        for field in [f for f in fields if f.init]:
+            type_class: type | str = "Unknown"
+            try:
+                type_class = field.type.__class__
+                class_factory = self.typing_classes[type_class]
+                value: Any = class_factory.process(
+                    obj=obj,
+                    field=field,
+                    factory_classes=self.factory_classes,
+                )
+            except KeyError as exc:
+                raise exceptions.ModelClassFactoryException(
+                    "The class of this dataclass field is not supported. "
+                    f"{field.name=}; "
+                    f"{field.type=}; "
+                    f"{field.type.__class__=}; "
+                ) from exc
+            params[field.name] = value
+        return cls(**params)

alpha/factories/models/factory_classes.py

@@ -0,0 +1,20 @@
+"""Contains FactoryClasses dataclass"""
+
+from dataclasses import dataclass
+
+from alpha.interfaces.factories import (
+    ClassFactory,
+    DefaultFactory,
+    ModelClassFactoryInstance,
+    TypeFactory,
+)
+
+
+@dataclass
+class FactoryClasses:
+    """A FactoryClasses instance acts as a toolbox for Factory classes"""
+
+    class_factories: dict[str, ClassFactory]
+    type_factories: dict[str, TypeFactory]
+    default_factory: DefaultFactory
+    model_class_factory: ModelClassFactoryInstance | None

alpha/factories/request_factory.py

@@ -0,0 +1,211 @@
+"""Contains RequestFactory class"""
+
+import sys
+import types
+import typing
+from enum import Enum
+from typing import Any, Callable, get_args, get_origin
+
+from alpha import exceptions
+from alpha.factories._type_conversion_matrix import TYPE_CONVERSION_MATRIX
+from alpha.factories.model_class_factory import (
+    ModelClassFactory,
+)
+from alpha.factories.type_factories import (
+    EnumTypeFactory,
+    GenericTypeFactory,
+    JsonPatchTypeFactory,
+)
+from alpha.infra.models.json_patch import JsonPatch
+from alpha.interfaces.dataclass_instance import DataclassInstance
+from alpha.interfaces.factories import (
+    ModelClassFactoryInstance,
+    TypeFactory,
+)
+from alpha.interfaces.openapi_model import OpenAPIModel
+
+
+class RequestFactory:
+    """This class handles API requests"""
+
+    def __init__(
+        self,
+        func: Callable[[Any], Any],
+        cast_args: bool = True,
+        use_model_class_factory: bool = True,
+        model_class_factory: type[
+            ModelClassFactoryInstance
+        ] = ModelClassFactory,
+        generic_type_factory: type[TypeFactory] = GenericTypeFactory,
+        enum_type_factory: type[TypeFactory] = EnumTypeFactory,
+        json_patch_type_factory: type[TypeFactory] = JsonPatchTypeFactory,
+    ) -> None:
+        """Initializing the class with a service function
+        The service function will be called when calling
+        the cls.__call__ function.
+
+        Parameters
+        ----------
+        func
+            A callable service function
+        cast_args, optional
+            Make use of the GenericTypeFactory to cast arguments,
+            by default True
+        use_model_class_factory, optional
+            Make use of the ModelClassFactory to map objects to a dataclass,
+            by default True
+        model_class_factory, optional
+            A ModelClassFactory class
+            by default ModelClassFactory
+        generic_type_factory, optional
+            A TypeFactory that can handle generic types
+            by default GenericTypeFactory
+        enum_type_factory, optional
+            A TypeFactory that can handle enum types
+            by default EnumTypeFactory
+        json_patch_type_factory, optional
+            A TypeFactory that can handle a JsonPatch type
+            by default JsonPatchTypeFactory
+        """
+        self.func = func
+        self.cast_args = cast_args
+        self.use_model_class_factory = use_model_class_factory
+        self.model_class_factory = model_class_factory
+        self.generic_type_factory = generic_type_factory
+        self.enum_type_factory = enum_type_factory
+        self.json_patch_type_factory = json_patch_type_factory
+
+    def __call__(self, **kwargs: dict[str, Any]) -> Any:
+        """Calling the service function
+        Any keyword argument will be parsed by the self._parse_args function
+        Each argument will be mapped on the functions parameter type of the
+        corresponding keyword.
+
+        The keyword arguments need to match the functions parameters.
+        Therefore, *args or **kwargs are not allowed as the functions
+        parameters.
+
+        Parameters
+        ----------
+        kwargs
+            Any keyword argument that will be passed to the service function
+
+        Returns
+        -------
+        Any
+            The returned object of the called service function
+        """
+        annotations = self.func.__annotations__
+        params = {
+            k: self._parse_args(key=k, value=v, cls=annotations[k])
+            for k, v in kwargs.items()
+        }
+
+        return self.func(**params)  # type: ignore
+
+    def _parse_args(
+        self,
+        key: str,
+        value: Any,
+        cls: Any | list[Any],
+    ) -> Any:
+        """Parsing each keyword argument
+
+        Parameters
+        ----------
+        key
+            Keyword of the argument
+        value
+            The argument
+        cls
+            The class of the corresponding parameter
+
+        Returns
+        -------
+        Any
+            Mapped objects
+
+        Raises
+        ------
+        exceptions.ClassMismatchException
+            When the source and destination types are not both of an iterable
+            type
+        """
+        union_types = getattr(typing, "_UnionGenericAlias")
+
+        if sys.version_info.minor >= 10:
+            union_types = (
+                getattr(typing, "_UnionGenericAlias") | types.UnionType
+            )
+
+        if isinstance(cls, union_types):
+            union_args = get_args(cls)
+            if value is None and type(None) in union_args:
+                return value
+            cls = union_args[0]
+
+        if get_origin(cls) in [list, set, tuple]:
+            if type(value) not in [list, set, tuple]:
+                raise exceptions.ClassMismatchException(
+                    "The targeted object type is an iterable but the source "
+                    "object is not"
+                )
+            arg = get_args(cls)[0]
+            return [
+                self._parse_args(key=key, value=item, cls=arg)
+                for item in value
+            ]
+
+        if isinstance(cls, DataclassInstance):
+            return self._to_dataclass(value=value, cls=cls)
+
+        if isinstance(cls, type(Enum)):
+            return self.enum_type_factory().process(
+                key=key, value=value, cls=cls
+            )
+
+        if cls == JsonPatch:
+            return self.json_patch_type_factory().process(
+                key=key, value=value, cls=cls
+            )
+
+        if cls in TYPE_CONVERSION_MATRIX.keys() and self.cast_args:
+            return self.generic_type_factory().process(
+                key=key, value=value, cls=cls
+            )
+
+        return value
+
+    def _to_dataclass(
+        self, value: OpenAPIModel | Any, cls: DataclassInstance
+    ) -> Any:
+        """Handling the mapping from an OpenAPI Model instance to a dataclass
+        The ModelClassFactory will be used if the cls does not have
+        a 'from_dict' method
+
+        Parameters
+        ----------
+        value
+            The argument, which is an OpenAPI Model
+        cls
+            The class of the corresponding parameter
+
+        Returns
+        -------
+        dataclass
+            Dataclass object
+
+        Raises
+        ------
+        TypeError
+            The value is not an instance of the OpenAPI (Base)Model
+        """
+        if not isinstance(value, OpenAPIModel):
+            raise TypeError(f"Unable to map {type(value)} on dataclass model")
+
+        if hasattr(cls, "from_dict"):
+            return getattr(cls, "from_dict")(value.to_dict())
+
+        if self.use_model_class_factory:
+            return self.model_class_factory().process(obj=value, cls=cls)
+        return value