dddesign 0.0.1__tar.gz

dddesign-0.0.1/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Artem Davydov
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

dddesign-0.0.1/PKG-INFO

@@ -0,0 +1,14 @@
+Metadata-Version: 2.1
+Name: dddesign
+Version: 0.0.1
+Summary: Domain Driven Design Library
+Author: davyddd
+Requires-Python: >=3.8,<3.11
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Requires-Dist: pydantic (>=1.10,<2.0)
+Description-Content-Type: text/markdown
+
+# dddesign

dddesign-0.0.1/README.md

@@ -0,0 +1 @@
+# dddesign

dddesign-0.0.1/dddesign/__init__.py

@@ -0,0 +1 @@
+__all__ = ('structure', 'types', 'unittest', 'utils')

dddesign-0.0.1/dddesign/structure/__init__.py

@@ -0,0 +1 @@
+__all__ = ('applications', 'domains', 'infrastructure', 'services')

dddesign-0.0.1/dddesign/structure/applications/__init__.py

@@ -0,0 +1,2 @@
+from .application import Application
+from .application_factory import ApplicationDependencyMapper, ApplicationFactory

dddesign-0.0.1/dddesign/structure/applications/application.py

@@ -0,0 +1,7 @@
+from pydantic import BaseModel
+
+
+class Application(BaseModel):
+    class Config:
+        allow_mutation = False
+        arbitrary_types_allowed = True

dddesign-0.0.1/dddesign/structure/applications/application_factory.py

@@ -0,0 +1,230 @@
+from typing import Any, Dict, Generic, NamedTuple, Optional, Tuple, Type, TypeVar, Union
+
+from pydantic import BaseModel, PrivateAttr, root_validator, validator
+
+from dddesign.structure.applications import Application
+from dddesign.structure.domains.constants import BaseEnum
+from dddesign.structure.domains.errors import BaseError
+from dddesign.structure.infrastructure.adapters.external import ExternalAdapter
+from dddesign.structure.infrastructure.adapters.internal import InternalAdapter
+from dddesign.structure.infrastructure.repositories import Repository
+from dddesign.structure.services.service import Service
+from dddesign.utils.base_model import create_pydantic_error_instance
+from dddesign.utils.convertors import convert_camel_case_to_snake_case
+from dddesign.utils.type_helpers import is_subclass_smart
+
+ApplicationT = TypeVar('ApplicationT')
+
+DependencyValue = Union[
+    InternalAdapter,
+    ExternalAdapter,
+    Repository,
+    Application,
+    Service,
+    Type[InternalAdapter],
+    Type[ExternalAdapter],
+    Type[Repository],
+    Type[Application],
+    Type[Service],
+]
+DEPENDENCY_VALUE_TYPES = tuple(_v for _v in getattr(DependencyValue, '__args__', ()) if isinstance(_v, type))
+
+RequestAttributeName = str
+RequestAttributeValue = Any
+RequestAttributeValueCombination = Tuple[RequestAttributeValue, ...]
+
+
+class RequestAttributeNotProvideError(BaseError):
+    message = 'Request attribute `{attribute_name}` not provide'
+
+
+class RequestAttributeValueError(BaseError):
+    message = 'Request attribute `{attribute_name}` has invalid value `{attribute_value}`'
+    status_code = 404
+
+
+class RequestAttribute(NamedTuple):
+    name: RequestAttributeName
+    enum_class: Type[BaseEnum]
+
+
+class ApplicationDependencyMapper(BaseModel):
+    request_attribute_name: Optional[RequestAttributeName] = None
+    request_attribute_value_map: Dict[RequestAttributeValue, Any]
+    application_attribute_name: str
+
+    class Config:
+        allow_mutation = False
+
+    @staticmethod
+    def _get_enum_class(request_attribute_value_map: Dict[RequestAttributeValue, DependencyValue]) -> Type[BaseEnum]:
+        return next(iter(request_attribute_value_map.keys())).__class__
+
+    @property
+    def enum_class(self) -> Type[BaseEnum]:
+        return self._get_enum_class(self.request_attribute_value_map)
+
+    def get_request_attribute_name(self) -> RequestAttributeName:
+        return self.request_attribute_name or convert_camel_case_to_snake_case(self.enum_class.__name__)
+
+    @staticmethod
+    def _is_dependency_value(value: Any) -> bool:
+        if isinstance(value, type):
+            return is_subclass_smart(value, *DEPENDENCY_VALUE_TYPES)
+        else:
+            return isinstance(value, DEPENDENCY_VALUE_TYPES)
+
+    @validator('request_attribute_value_map')
+    def validate_request_attribute_value_map(cls, request_attribute_value_map):
+        if len(request_attribute_value_map) == 0:
+            raise create_pydantic_error_instance(
+                base_error=ValueError,
+                code='empty_request_attribute_value_map',
+                msg_template='`request_attribute_value_map` must contain at least one element',
+            )
+
+        enum_class = cls._get_enum_class(request_attribute_value_map)
+        if not is_subclass_smart(enum_class, BaseEnum):
+            raise create_pydantic_error_instance(
+                base_error=ValueError,
+                code='incorrect_request_attribute_value',
+                msg_template='All keys of `request_attribute_value_map` must be instances of `BaseEnum`',
+            )
+        elif not all(isinstance(key, enum_class) for key in request_attribute_value_map):
+            raise create_pydantic_error_instance(
+                base_error=ValueError,
+                code='another_types_request_attribute_values',
+                msg_template='All keys of `request_attribute_value_map` must be instances of the same enum class',
+            )
+        elif set(enum_class) ^ set(request_attribute_value_map.keys()):
+            raise create_pydantic_error_instance(
+                base_error=ValueError,
+                code='not_enough_request_attribute_values',
+                msg_template=(
+                    f'All elements of `{enum_class.__name__}` enum must announced '
+                    'as key in `request_attribute_value_map` attribute'
+                ),
+            )
+        elif any(not cls._is_dependency_value(value) for value in request_attribute_value_map.values()):
+            raise create_pydantic_error_instance(
+                base_error=ValueError,
+                code='incorrect_type_dependency_value',
+                msg_template='All values of `request_attribute_value_map` must be instances of `DependencyValue`',
+            )
+
+        dependency_values = tuple(request_attribute_value_map.values())
+        if dependency_values:
+            amount_equal_values = 0
+            first_dependency_value = dependency_values[0]
+            for dependency_value in dependency_values[1:]:
+                if dependency_value != first_dependency_value:
+                    break
+
+                if (
+                    not isinstance(dependency_value, type)
+                    and dependency_value == first_dependency_value
+                    and dependency_value.__class__ != first_dependency_value.__class__
+                ):
+                    break
+
+                amount_equal_values += 1
+
+            if amount_equal_values == len(dependency_values) - 1:
+                raise create_pydantic_error_instance(
+                    base_error=ValueError,
+                    code='not_unique_dependency_values',
+                    msg_template='`request_attribute_value_map` must contain more than one unique value',
+                )
+        return request_attribute_value_map
+
+
+class ApplicationFactory(BaseModel, Generic[ApplicationT]):
+    dependency_mappers: Tuple[ApplicationDependencyMapper, ...] = ()
+    application_class: Type[ApplicationT]
+    reuse_implementations: bool = True
+
+    # private attributes
+    _request_attributes: Tuple[RequestAttribute, ...] = PrivateAttr()
+    _application_implementations: Dict[RequestAttributeValueCombination, ApplicationT] = PrivateAttr()
+
+    class Config:
+        allow_mutation = False
+
+    def __init__(self, **data: Any) -> None:
+        super().__init__(**data)
+        self._request_attributes = self._get_request_attributes()
+        self._application_implementations = {}
+
+    def _get_request_attributes(self) -> Tuple[RequestAttribute, ...]:
+        return tuple(
+            RequestAttribute(name=mapper.get_request_attribute_name(), enum_class=mapper.enum_class)
+            for mapper in self.dependency_mappers
+        )
+
+    @validator('dependency_mappers')
+    def validate_dependency_mappers(cls, dependency_mappers):
+        if len(dependency_mappers) != len({mapper.enum_class for mapper in dependency_mappers}):
+            raise ValueError('`dependency_mappers` must contain unique enum classes')
+        elif len(dependency_mappers) != len({mapper.application_attribute_name for mapper in dependency_mappers}):
+            raise ValueError('`dependency_mappers` must contain unique `application_attribute_name`')
+        elif len(dependency_mappers) != len({mapper.get_request_attribute_name() for mapper in dependency_mappers}):
+            raise ValueError('`dependency_mappers` must contain unique `request_attribute_name`')
+
+        return dependency_mappers
+
+    @root_validator
+    def validate_consistency(cls, values):
+        application_class = values['application_class']
+        dependency_mappers = values['dependency_mappers']
+
+        application_required_attribute_names = {name for name, field in application_class.__fields__.items() if field.required}
+        requested_dependency_attribute_names = {mapper.application_attribute_name for mapper in dependency_mappers}
+
+        if not (application_required_attribute_names <= requested_dependency_attribute_names):
+            raise ValueError('`dependency_mappers` must contain all required attributes of `application_class`')
+
+        return values
+
+    def _get_request_attribute_value_combination(self, **kwargs: RequestAttributeValue) -> RequestAttributeValueCombination:
+        request_attribute_value_combination = []
+        for attribute in self._request_attributes:
+            if attribute.name in kwargs:
+                try:
+                    request_attribute_value_combination.append(attribute.enum_class(kwargs[attribute.name]))
+                except ValueError as err:
+                    raise RequestAttributeValueError(
+                        attribute_name=attribute.name, attribute_value=kwargs[attribute.name]
+                    ) from err
+            else:
+                raise RequestAttributeNotProvideError(attribute_name=attribute.name)
+
+        return tuple(request_attribute_value_combination)
+
+    def _get_application_implementation(self, **kwargs: RequestAttributeValue) -> ApplicationT:
+        request_attribute_value_combination = self._get_request_attribute_value_combination(**kwargs)
+
+        if request_attribute_value_combination in self._application_implementations:
+            return self._application_implementations[request_attribute_value_combination]
+
+        application_impl = self.application_class(
+            **{
+                self.dependency_mappers[index].application_attribute_name: dependency_value
+                for index in range(len(request_attribute_value_combination))
+                if (
+                    dependency_value := self.dependency_mappers[index].request_attribute_value_map[
+                        request_attribute_value_combination[index]
+                    ]
+                )
+            }
+        )
+        if self.reuse_implementations:
+            self._application_implementations[request_attribute_value_combination] = application_impl
+
+        return application_impl
+
+    @property
+    def request_attributes(self) -> Tuple[RequestAttribute, ...]:
+        return self._request_attributes
+
+    def get(self, **kwargs: RequestAttributeValue) -> ApplicationT:
+        return self._get_application_implementation(**kwargs)

dddesign-0.0.1/dddesign/structure/domains/__init__.py

@@ -0,0 +1 @@
+__all__ = ('aggregates', 'constants', 'dto', 'entities', 'errors', 'value_objects')

dddesign-0.0.1/dddesign/structure/domains/aggregates/__init__.py

@@ -0,0 +1,2 @@
+from .aggregate import Aggregate
+from .aggregate_list_factory import AggregateListFactory

dddesign-0.0.1/dddesign/structure/domains/aggregates/aggregate.py

@@ -0,0 +1,7 @@
+from pydantic import BaseModel
+
+
+class Aggregate(BaseModel):
+    class Config:
+        validate_assignment = True
+        arbitrary_types_allowed = True

dddesign-0.0.1/dddesign/structure/domains/aggregates/aggregate_list_factory.py

@@ -0,0 +1,172 @@
+from typing import Any, Callable, Dict, Generic, Iterable, List, NamedTuple, Tuple, Type, TypeVar, get_args
+
+from pydantic import BaseModel, Field, PrivateAttr, root_validator
+
+from dddesign.structure.domains.aggregates.aggregate import Aggregate
+from dddesign.structure.domains.entities import Entity
+from dddesign.utils.type_helpers import get_type_without_optional
+
+RelatedObject = Any
+RelatedObjectId = Any
+
+AggregateT = TypeVar('AggregateT', bound=Aggregate)
+
+
+class MethodArgument(NamedTuple):
+    name: str
+    argument_class: Any
+
+    @classmethod
+    def factory(cls, name: str, argument_class: Any) -> 'MethodArgument':
+        return cls(name, get_type_without_optional(argument_class))
+
+    @property
+    def is_iterable(self) -> bool:
+        return hasattr(getattr(self.argument_class, '__origin__', self.argument_class), '__iter__')
+
+
+class AggregateDependencyMapper(BaseModel):
+    entity_attribute_name: str
+    aggregate_attribute_name: str
+
+    method_getter: Callable
+    method_extra_arguments: Dict[str, Any] = Field(default_factory=dict)
+
+    _method_related_object_id_argument: MethodArgument = PrivateAttr()
+    _related_object_id_attribute_name: str = PrivateAttr()
+
+    class Config:
+        allow_mutation = False
+        arbitrary_types_allowed = True
+
+    def __init__(self, **data: Any) -> None:
+        super().__init__(**data)
+        self._method_related_object_id_argument = self._get_method_related_object_id_argument()
+        self._related_object_id_attribute_name = self._get_related_object_id_attribute_name()
+
+    @property
+    def method_related_object_id_argument(self) -> MethodArgument:
+        return self._method_related_object_id_argument
+
+    @property
+    def related_object_id_attribute_name(self) -> str:
+        return self._related_object_id_attribute_name
+
+    def _get_method_related_object_id_argument(self) -> MethodArgument:
+        argument_name, argument_class = None, None
+        for _argument_name, _argument_class in self.method_getter.__annotations__.items():
+            if _argument_name in self.method_extra_arguments or _argument_name == 'return':
+                continue
+
+            if argument_name and argument_class:
+                raise ValueError('Method must have only one related argument')
+
+            argument_name, argument_class = _argument_name, _argument_class
+
+        if not (argument_name and argument_class):
+            raise ValueError('Method must have one related argument')
+
+        return MethodArgument.factory(argument_name, argument_class)
+
+    def _get_related_object_id_attribute_name(self) -> str:
+        related_object_class = get_type_without_optional(self.method_getter.__annotations__.get('return'))
+        if not related_object_class:
+            raise ValueError('Method must have return annotation')
+
+        related_object_id_attribute_class = self._method_related_object_id_argument.argument_class
+
+        if self._method_related_object_id_argument.is_iterable:
+            related_object_class = get_type_without_optional(get_args(related_object_class)[0])
+            related_object_id_attribute_class = get_type_without_optional(get_args(related_object_id_attribute_class)[0])
+
+        return {value: key for key, value in related_object_class.__annotations__.items()}[related_object_id_attribute_class]
+
+
+class AggregateListFactory(BaseModel, Generic[AggregateT]):
+    aggregate_class: Type[AggregateT]
+    aggregate_entity_attribute_name: str
+    dependency_mappers: Tuple[AggregateDependencyMapper, ...]
+
+    class Config:
+        allow_mutation = False
+        arbitrary_types_allowed = True
+
+    @root_validator
+    def validate_consistency(cls, values):
+        aggregate_class = values['aggregate_class']
+        aggregate_entity_attribute_name = values['aggregate_entity_attribute_name']
+        dependency_mappers = values['dependency_mappers']
+
+        if aggregate_entity_attribute_name not in aggregate_class.__annotations__:
+            raise ValueError(f"The aggregate class doesn't have `{aggregate_entity_attribute_name}` attribute")
+
+        if any(dependency.aggregate_attribute_name not in aggregate_class.__annotations__ for dependency in dependency_mappers):
+            raise ValueError("The aggregate class doesn't have a attribute from some declared dependency")
+
+        entity_class = get_type_without_optional(aggregate_class.__annotations__[aggregate_entity_attribute_name])
+
+        if any(dependency.entity_attribute_name not in entity_class.__annotations__ for dependency in dependency_mappers):
+            raise ValueError("The entity class doesn't have a attribute from some declared dependency")
+
+        return values
+
+    def create_list(self, entities: List[Entity]) -> List[AggregateT]:
+        dependency_related_object_ids_map: Dict[int, Tuple[RelatedObjectId, ...]] = {}
+        for dependency_item, dependency in enumerate(self.dependency_mappers):
+            _related_object_ids: List[RelatedObjectId] = []
+            for entity in entities:
+                related_value = getattr(entity, dependency.entity_attribute_name)
+                if isinstance(related_value, Iterable):
+                    _related_object_ids.extend(related_value)
+                else:
+                    _related_object_ids.append(related_value)
+
+            dependency_related_object_ids_map[dependency_item] = tuple(set(_related_object_ids))
+
+        dependency_related_object_map: Dict[int, Dict[RelatedObjectId, RelatedObject]] = {}
+        for dependency_item, related_object_ids in dependency_related_object_ids_map.items():
+            dependency = self.dependency_mappers[dependency_item]
+
+            if dependency.method_related_object_id_argument.is_iterable:
+                related_objects = dependency.method_getter(
+                    **{
+                        dependency.method_related_object_id_argument.name: related_object_ids,
+                        **dependency.method_extra_arguments,
+                    }
+                )
+            else:
+                related_objects = []
+                for related_object_id in related_object_ids:
+                    related_object = dependency.method_getter(
+                        **{
+                            dependency.method_related_object_id_argument.name: related_object_id,
+                            **dependency.method_extra_arguments,
+                        }
+                    )
+                    if related_object is not None:
+                        related_objects.append(related_object)
+
+            related_object_map: Dict[RelatedObjectId, RelatedObject] = {
+                getattr(related_object, dependency.related_object_id_attribute_name): related_object
+                for related_object in related_objects
+            }
+            dependency_related_object_map[dependency_item] = related_object_map
+
+        aggregates: List[AggregateT] = []
+        for entity in entities:
+            aggregate_init: Dict[str, Any] = {self.aggregate_entity_attribute_name: entity}
+            for dependency_item, dependency in enumerate(self.dependency_mappers):
+                if dependency.method_related_object_id_argument.is_iterable:
+                    aggregate_init[dependency.aggregate_attribute_name] = tuple(
+                        dependency_related_object_map[dependency_item].get(related_object_id)
+                        for related_object_id in getattr(entity, dependency.entity_attribute_name)
+                    )
+                else:
+                    aggregate_init[dependency.aggregate_attribute_name] = dependency_related_object_map[dependency_item].get(
+                        getattr(entity, dependency.entity_attribute_name)
+                    )
+
+            aggregate = self.aggregate_class(**aggregate_init)
+            aggregates.append(aggregate)
+
+        return aggregates

dddesign-0.0.1/dddesign/structure/domains/constants/__init__.py

@@ -0,0 +1 @@
+from .base_enum import BaseEnum

dddesign-0.0.1/dddesign/structure/domains/constants/base_enum.py

@@ -0,0 +1,10 @@
+from enum import Enum
+
+
+class BaseEnum(Enum):
+    def __str__(self):
+        return str(self.value)
+
+    @classmethod
+    def has_value(cls, value) -> bool:
+        return value in cls._value2member_map_

dddesign-0.0.1/dddesign/structure/domains/dto/__init__.py

@@ -0,0 +1 @@
+from .dto import DataTransferObject

dddesign-0.0.1/dddesign/structure/domains/dto/dto.py

@@ -0,0 +1,7 @@
+from pydantic import BaseModel
+
+
+class DataTransferObject(BaseModel):
+    class Config:
+        allow_mutation = False
+        arbitrary_types_allowed = True

dddesign-0.0.1/dddesign/structure/domains/entities/__init__.py

@@ -0,0 +1 @@
+from .entity import Entity

dddesign-0.0.1/dddesign/structure/domains/entities/entity.py

@@ -0,0 +1,14 @@
+from pydantic import BaseModel
+
+from dddesign.structure.domains.dto.dto import DataTransferObject
+
+
+class Entity(BaseModel):
+    class Config:
+        validate_assignment = True
+        arbitrary_types_allowed = True
+
+    def update(self, data: DataTransferObject):
+        for field_name, value in data.dict(exclude_unset=True).items():
+            if field_name in self.__fields__:
+                setattr(self, field_name, value)

dddesign-0.0.1/dddesign/structure/domains/errors/__init__.py

@@ -0,0 +1,2 @@
+from .base_error import BaseError
+from .collection_error import CollectionError

dddesign-0.0.1/dddesign/structure/domains/errors/base_error.py

@@ -0,0 +1,46 @@
+from typing import Any, Optional
+
+from dddesign.utils.convertors import convert_camel_case_to_snake_case
+
+
+class BaseError(Exception):
+    message: str
+    error_code: str
+    status_code: int
+    field_name: Optional[str]
+
+    def __init__(
+        self,
+        message: Optional[str] = None,
+        error_code: Optional[str] = None,
+        status_code: Optional[int] = None,
+        field_name: Optional[str] = None,
+        **kwargs: Any,
+    ):
+        message = message or getattr(self, 'message', None)
+        if not message:
+            raise ValueError('Field `message` is required')
+        self.message = message.format(**kwargs)
+
+        self.error_code = error_code or getattr(self, 'error_code', None) or self.get_error_code()
+
+        self.status_code = status_code or getattr(self, 'status_code', None) or 400
+
+        self.field_name = field_name or getattr(self, 'field_name', None)
+
+    def __str__(self) -> str:
+        return (
+            f'{self.__class__.__name__}(\n'
+            f"    message='{self.message}',\n"
+            f"    error_code='{self.error_code}',\n"
+            f"    status_code='{self.status_code}',\n"
+            f"    field_name='{self.field_name}'\n"
+            ')'
+        )
+
+    def __repr__(self) -> str:
+        return self.__str__()
+
+    @classmethod
+    def get_error_code(cls) -> str:
+        return convert_camel_case_to_snake_case(cls.__name__)

dddesign-0.0.1/dddesign/structure/domains/errors/collection_error.py

@@ -0,0 +1,32 @@
+from typing import List
+
+from dddesign.structure.domains.errors.base_error import BaseError
+
+
+class CollectionError(Exception):
+    errors: List[BaseError]
+
+    def __init__(self):
+        self.errors = []
+        self._index = 0
+
+    def __bool__(self) -> bool:
+        return bool(self.errors)
+
+    def __iter__(self):
+        return self
+
+    def __next__(self) -> BaseError:
+        if self._index >= len(self.errors):
+            self._index = 0
+            raise StopIteration
+
+        result = self.errors[self._index]
+        self._index += 1
+        return result
+
+    def add(self, error: BaseError):
+        if not isinstance(error, BaseError):
+            raise TypeError('`error` must be an instance of `BaseError`')
+
+        self.errors.append(error)

dddesign-0.0.1/dddesign/structure/domains/types/__init__.py

@@ -0,0 +1 @@
+from .base_type import BaseType

dddesign-0.0.1/dddesign/structure/domains/types/base_type.py

@@ -0,0 +1,11 @@
+from abc import ABCMeta, abstractmethod
+from typing import Generator
+
+from pydantic.typing import AnyCallable
+
+
+class BaseType(metaclass=ABCMeta):
+    @classmethod
+    @abstractmethod
+    def __get_validators__(cls) -> Generator[AnyCallable, None, None]:
+        ...

dddesign-0.0.1/dddesign/structure/domains/value_objects/__init__.py

@@ -0,0 +1 @@
+from .value_object import ValueObject

dddesign-0.0.1/dddesign/structure/domains/value_objects/value_object.py

@@ -0,0 +1,7 @@
+from pydantic import BaseModel
+
+
+class ValueObject(BaseModel):
+    class Config:
+        allow_mutation = False
+        arbitrary_types_allowed = True

dddesign-0.0.1/dddesign/structure/infrastructure/__init__.py

@@ -0,0 +1 @@
+__all__ = ('adapters', 'repositories')

dddesign-0.0.1/dddesign/structure/infrastructure/adapters/__init__.py

@@ -0,0 +1 @@
+__all__ = ('external', 'internal')

dddesign-0.0.1/dddesign/structure/infrastructure/adapters/external/__init__.py

@@ -0,0 +1 @@
+from .external_adapter import ExternalAdapter

dddesign-0.0.1/dddesign/structure/infrastructure/adapters/external/external_adapter.py

@@ -0,0 +1,7 @@
+from pydantic import BaseModel
+
+
+class ExternalAdapter(BaseModel):
+    class Config:
+        allow_mutation = False
+        arbitrary_types_allowed = True

dddesign-0.0.1/dddesign/structure/infrastructure/adapters/internal/__init__.py

@@ -0,0 +1 @@
+from .internal_adapter import InternalAdapter

dddesign-0.0.1/dddesign/structure/infrastructure/adapters/internal/internal_adapter.py

@@ -0,0 +1,7 @@
+from pydantic import BaseModel
+
+
+class InternalAdapter(BaseModel):
+    class Config:
+        allow_mutation = False
+        arbitrary_types_allowed = True

dddesign-0.0.1/dddesign/structure/infrastructure/repositories/__init__.py

@@ -0,0 +1 @@
+from .repository import Repository

dddesign-0.0.1/dddesign/structure/infrastructure/repositories/repository.py

@@ -0,0 +1,7 @@
+from pydantic import BaseModel
+
+
+class Repository(BaseModel):
+    class Config:
+        allow_mutation = False
+        arbitrary_types_allowed = True

dddesign-0.0.1/dddesign/structure/services/__init__.py

@@ -0,0 +1 @@
+from .service import Service

dddesign-0.0.1/dddesign/structure/services/service.py

@@ -0,0 +1,13 @@
+from abc import ABCMeta, abstractmethod
+
+from pydantic import BaseModel
+
+
+class Service(BaseModel, metaclass=ABCMeta):
+    class Config:
+        allow_mutation = False
+        arbitrary_types_allowed = True
+
+    @abstractmethod
+    def handle(self):
+        ...

dddesign-0.0.1/dddesign/types/__init__.py

@@ -0,0 +1,2 @@
+from .email_str import EmailStr
+from .string_uuid import StringUUID

dddesign-0.0.1/dddesign/types/email_str.py

@@ -0,0 +1,13 @@
+from typing import Any
+
+from pydantic.networks import EmailStr as PydanticEmailStr
+
+from dddesign.structure.domains.types.base_type import BaseType
+
+
+class EmailStr(PydanticEmailStr, BaseType):
+    @classmethod
+    def validate(cls, value: Any) -> 'EmailStr':
+        if isinstance(value, str):
+            value = value.lower().strip()
+        return cls(super().validate(value))

dddesign-0.0.1/dddesign/types/string_uuid.py

@@ -0,0 +1,47 @@
+from typing import Any, Callable, Generator
+from uuid import UUID
+
+from dddesign.structure.domains.types import BaseType
+
+
+class StringUUID(str, BaseType):
+    """
+    A UUID that is serialized as a string.
+
+    The field will be validated as a UUID and then serialized (and stored internally) as a string.
+    This is safe to use in cases where json.dumps() is utilized for serialization.
+    You will not get punished by `TypeError: Object of type UUID is not JSON serializable` for this anymore.
+
+    Example:
+    ```python
+        from pydantic import BaseModel
+
+        class MyModel(BaseModel):
+            id: StringUUID
+
+        my_model = MyModel(id='123e4567-e89b-12d3-a456-426655440000')
+
+        json.dumps(my_model.dict())  # it's working
+
+        # You can compare it with a string or a UUID
+        my_model.id == '123e4567-e89b-12d3-a456-426655440000'
+        my_model.id == UUID('123e4567-e89b-12d3-a456-426655440000')
+    ```
+    """
+
+    def __eq__(self, other: Any) -> bool:
+        if isinstance(other, UUID):
+            other = type(self)(other)
+        return super().__eq__(other)
+
+    def __hash__(self) -> int:
+        return hash(str(self))
+
+    @classmethod
+    def __get_validators__(cls) -> Generator[Callable[[Any], 'StringUUID'], None, None]:
+        yield cls.validate
+
+    @classmethod
+    def validate(cls, value: Any) -> 'StringUUID':
+        value = UUID(str(value))
+        return cls(value)

dddesign-0.0.1/dddesign/unittest/__init__.py

@@ -0,0 +1 @@
+__all__ = ('magic_mock',)

dddesign-0.0.1/dddesign/unittest/magic_mock.py

@@ -0,0 +1,19 @@
+from unittest.mock import MagicMock as OriginalMagicMock
+
+from pydantic import BaseModel
+
+from dddesign.utils.sequence_helpers import get_safe_element
+from dddesign.utils.type_helpers import is_subclass_smart
+
+
+class MagicMock(OriginalMagicMock):
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        class_type = (
+            get_safe_element(args, 0)  # spec
+            or get_safe_element(args, 5)  # spec_set
+            or kwargs.get('spec')
+            or kwargs.get('spec_set')
+        )
+        if is_subclass_smart(class_type, BaseModel):
+            self._copy_and_set_values.return_value = self  # some magic

dddesign-0.0.1/dddesign/utils/__init__.py

@@ -0,0 +1 @@
+__all__ = ('base_model', 'convertors', 'function_exceptions_extractor', 'module_getter', 'sequence_helpers', 'type_helpers')

dddesign-0.0.1/dddesign/utils/base_model/__init__.py

@@ -0,0 +1,3 @@
+from .changes_tracker import TrackChangesMixin
+from .error_instance_factory import create_pydantic_error_instance
+from .error_wrapper import wrap_error

dddesign-0.0.1/dddesign/utils/base_model/changes_tracker.py

@@ -0,0 +1,45 @@
+from typing import Any, Dict, Generator, Optional, Tuple
+
+from pydantic import BaseModel, PrivateAttr
+
+UndefinedValue = object()
+
+
+class TrackChangesMixin(BaseModel):
+    _initial_state: Dict[str, Any] = PrivateAttr()
+
+    def __init__(self, **data: Any) -> None:
+        super().__init__(**data)
+        self.update_initial_state()
+
+    def _get_changed_fields(self) -> Generator[str, None, None]:
+        for field, value in self.dict().items():
+            if self._initial_state.get(field, UndefinedValue) != value:
+                yield field
+
+    @property
+    def has_changed(self) -> bool:
+        return next(self._get_changed_fields(), None) is not None
+
+    @property
+    def changed_fields(self) -> Tuple[str, ...]:
+        return tuple(self._get_changed_fields())
+
+    @property
+    def changed_data(self) -> Dict[str, Any]:
+        return {field: getattr(self, field, None) for field in self._get_changed_fields()}
+
+    @property
+    def diffs(self) -> Dict[str, Tuple[Any, Any]]:
+        return {field: (self._initial_state[field], getattr(self, field, None)) for field in self._get_changed_fields()}
+
+    @property
+    def initial_state(self) -> Dict[str, Any]:
+        return self._initial_state
+
+    def update_initial_state(self, fields: Optional[tuple] = None):
+        if fields:
+            for field in fields:
+                self._initial_state[field] = self.dict()[field]
+        else:
+            self._initial_state = self.dict()

dddesign-0.0.1/dddesign/utils/base_model/error_instance_factory.py

@@ -0,0 +1,15 @@
+from typing import Optional, Type, TypeVar
+
+from pydantic.errors import PydanticErrorMixin
+
+BaseError = TypeVar('BaseError', bound=Exception)
+
+
+def create_pydantic_error_instance(
+    base_error: Type[BaseError], code: str, msg_template: str, context: Optional[dict] = None
+) -> BaseError:
+    _class = type('PydanticError', (PydanticErrorMixin, base_error), {'code': code, 'msg_template': msg_template})
+    if isinstance(context, dict):
+        return _class(**context)
+    else:
+        return _class()

dddesign-0.0.1/dddesign/utils/base_model/error_wrapper.py

@@ -0,0 +1,27 @@
+from typing import Optional
+
+from pydantic import ValidationError
+
+from dddesign.structure.domains.errors import BaseError, CollectionError
+
+CONTEXT_MESSAGES_PARAM = '__messages__'
+
+
+def wrap_error(error: ValidationError) -> CollectionError:
+    if not isinstance(error, ValidationError):
+        raise TypeError('`exception` must be an instance of `pydantic.ValidationError`')
+
+    errors = CollectionError()
+
+    for _error in error.errors():
+        field_name: Optional[str] = '.'.join(str(item) for item in _error['loc'])
+        if field_name == '__root_validator__':
+            field_name = None
+
+        if 'ctx' in _error and CONTEXT_MESSAGES_PARAM in _error['ctx']:
+            for msg in _error['ctx'][CONTEXT_MESSAGES_PARAM]:
+                errors.add(BaseError(message=msg, field_name=field_name))
+        else:
+            errors.add(BaseError(message=_error['msg'], field_name=field_name))
+
+    return errors

dddesign-0.0.1/dddesign/utils/convertors.py

@@ -0,0 +1,2 @@
+def convert_camel_case_to_snake_case(string: str) -> str:
+    return ''.join(f'_{char.lower()}' if char.isupper() else char for char in string).lstrip('_')

dddesign-0.0.1/dddesign/utils/function_exceptions_extractor.py

@@ -0,0 +1,76 @@
+import ast
+import builtins
+import inspect
+import textwrap
+from importlib import import_module
+from typing import Any, Callable, Dict, Generator, Optional, Tuple, Type
+
+from pydantic import BaseModel, Field, validator
+
+from dddesign.utils.module_getter import get_module
+
+
+class ExceptionInfo(BaseModel):
+    exception_class: Type[Exception]
+    args: Tuple[Any, ...] = Field(default_factory=tuple)
+    kwargs: Dict[str, Any] = Field(default_factory=dict)
+
+    @validator('args')
+    def validate_args(cls, value):
+        return tuple(_v.value if isinstance(_v, ast.Constant) else None for _v in value)
+
+    @validator('kwargs')
+    def validate_kwargs(cls, value):
+        return {_k: _v.value if isinstance(_v, ast.Constant) else None for _k, _v in value.items()}
+
+    def get_kwargs(self):
+        annotations = tuple(
+            argument_name
+            for argument_name in inspect.signature(self.exception_class.__init__).parameters
+            if argument_name not in ('self', 'args', 'kwargs')
+        )
+
+        return {
+            **{attribute_name: self.args[item] for item, attribute_name in enumerate(annotations[: len(self.args)])},
+            **self.kwargs,
+        }
+
+    def get_exception_instance(self):
+        kwargs = {k: f'<{k}>' if v is None else v for k, v in self.get_kwargs().items()}
+        return self.exception_class(**kwargs)
+
+
+def extract_function_exceptions(func: Callable) -> Generator[ExceptionInfo, None, None]:
+    source = textwrap.dedent(inspect.getsource(func))
+    tree = ast.parse(source)
+
+    for node in ast.walk(tree):
+        if isinstance(node, ast.Raise):
+            exception_name: Optional[str] = None
+            exception_args: Tuple[Any, ...] = ()
+            exception_kwargs: Dict[str, Any] = {}
+
+            if isinstance(node.exc, ast.Call):
+                exception_name = ast.unparse(node.exc.func)
+                exception_args = tuple(node.exc.args)
+                exception_kwargs = {kw.arg: kw.value for kw in node.exc.keywords if isinstance(kw.arg, str)}
+            elif isinstance(node.exc, (ast.Attribute, ast.Name)):
+                exception_name = ast.unparse(node.exc)
+
+            if not exception_name:
+                continue
+
+            exception_name_slices = exception_name.split('.')
+            class_name = exception_name_slices[-1]
+            sub_modules = exception_name_slices[:-1]
+
+            exception_module = get_module(import_module(func.__module__), sub_modules)
+
+            exception_class: Optional[Type[Exception]] = getattr(exception_module, class_name, None)
+            if exception_class is None and hasattr(builtins, exception_name):
+                exception_class = getattr(builtins, exception_name)
+
+            if exception_class is None:
+                continue
+
+            yield ExceptionInfo(exception_class=exception_class, args=exception_args, kwargs=exception_kwargs)

dddesign-0.0.1/dddesign/utils/module_getter.py

@@ -0,0 +1,20 @@
+from types import ModuleType
+from typing import List
+
+
+def get_module(module: ModuleType, sub_modules: List[str]) -> ModuleType:
+    if not module:
+        raise ValueError('Argument `module` is required')
+    elif not isinstance(sub_modules, list):
+        raise ValueError('Argument `sub_modules` must be a list of strings')
+
+    if len(sub_modules) == 0:
+        return module
+
+    sub_module = sub_modules.pop(0)
+
+    if hasattr(module, sub_module):
+        module = getattr(module, sub_module)
+        return get_module(module, sub_modules)
+    else:
+        raise ValueError(f'Module {sub_module} not found in {module.__name__}')

dddesign-0.0.1/dddesign/utils/safe_decorators.py

@@ -0,0 +1,48 @@
+import logging
+from functools import wraps
+from typing import Any, Callable, Optional, Tuple, Type
+
+logger = logging.getLogger(__name__)
+
+
+def safe_call(
+    func: Optional[Callable] = None,
+    capture_exception: bool = True,
+    default_result: Optional[Any] = None,
+    exceptions: Tuple[Type[Exception], ...] = (Exception,),
+) -> Callable:
+    if func is None:
+        return lambda _func: safe_call(func=_func, capture_exception=capture_exception, default_result=default_result)
+
+    @wraps(func)
+    def wrapped_func(*args, **kwargs):
+        try:
+            result = func(*args, **kwargs)
+        except exceptions as error:
+            if capture_exception:
+                logger.exception(error)
+
+            result = default_result
+
+        return result
+
+    return wrapped_func
+
+
+def retry_once_after_exception(
+    func: Optional[Callable] = None, capture_exception: bool = True, exceptions: Tuple[Type[Exception], ...] = (Exception,)
+) -> Callable:
+    if func is None:
+        return lambda _func: retry_once_after_exception(func=_func, exceptions=exceptions)
+
+    @wraps(func)
+    def wrapped_func(*args, **kwargs):
+        try:
+            return func(*args, **kwargs)
+        except exceptions as error:
+            if capture_exception:
+                logger.exception(error)
+
+            return func(*args, **kwargs)
+
+    return wrapped_func

dddesign-0.0.1/dddesign/utils/sequence_helpers.py

@@ -0,0 +1,8 @@
+from typing import Any, Sequence
+
+
+def get_safe_element(seq: Sequence[Any], index: int) -> Any:
+    try:
+        return seq[index]
+    except IndexError:
+        return None

dddesign-0.0.1/dddesign/utils/type_helpers.py

@@ -0,0 +1,67 @@
+import inspect
+from datetime import date, datetime, time, timedelta
+from decimal import Decimal
+from ipaddress import IPv4Address, IPv6Address
+from types import CodeType, FunctionType
+from typing import Any, Callable, Optional, Type, Union, get_args
+from uuid import UUID
+
+PythonType = Union[str, float, bool, bytes, int, dict, date, time, datetime, timedelta, UUID, Decimal, IPv4Address, IPv6Address]
+
+
+def is_subclass_smart(class_type: Any, *base_types: Any) -> bool:
+    class_type = getattr(class_type, '__origin__', class_type)
+    return inspect.isclass(class_type) and issubclass(class_type, base_types)
+
+
+def get_type_without_optional(class_type: Any) -> Any:
+    return get_args(class_type)[0] if type(None) in get_args(class_type) else class_type
+
+
+def get_origin_class_of_method(cls: Any, method_name: str):
+    for base in inspect.getmro(cls):
+        if method_name in base.__dict__:
+            return base
+
+
+def _is_python_type(type_) -> bool:
+    return is_subclass_smart(type_, getattr(PythonType, '__args__', None))
+
+
+def get_python_type(type_) -> Type[PythonType]:
+    if hasattr(type_, '__supertype__'):
+        return get_python_type(type_.__supertype__)
+    elif hasattr(type_, '__origin__'):
+        return get_python_type(type_.__args__[0])
+    elif hasattr(type_, '__bases__'):
+        next_type = type_.__bases__[0]
+        if _is_python_type(type_) and not _is_python_type(next_type):
+            return type_
+        else:
+            return get_python_type(next_type)
+    else:
+        raise TypeError(f'Unknown type: {type(type_)}')
+
+
+def get_new_function(func: Callable, new_name: Optional[str] = None) -> Callable:
+    base_code = func.__code__
+    func_name = new_name or base_code.co_name
+    new_code = CodeType(
+        base_code.co_argcount,
+        base_code.co_posonlyargcount,
+        base_code.co_kwonlyargcount,
+        base_code.co_nlocals,
+        base_code.co_stacksize,
+        base_code.co_flags,
+        base_code.co_code,
+        base_code.co_consts,
+        base_code.co_names,
+        base_code.co_varnames,
+        base_code.co_filename,
+        func_name,
+        base_code.co_firstlineno,
+        base_code.co_lnotab,
+        base_code.co_freevars,
+        base_code.co_cellvars,
+    )
+    return FunctionType(new_code, func.__globals__)

dddesign-0.0.1/pyproject.toml

@@ -0,0 +1,22 @@
+[tool.poetry]
+name = "dddesign"
+description = "Domain Driven Design Library"
+version = "0.0.1"
+authors = ["davyddd"]
+readme = "README.md"
+packages = [{include = "dddesign"}]
+
+[tool.poetry.dependencies]
+python = ">=3.8,<3.11"
+pydantic = "^1.10"
+
+[tool.poetry.group.dev.dependencies]
+mypy = "1.1.1"
+ruff = "0.1.7"
+ipdb = "0.13.9"
+ipython = "8.12.3"
+pytest = "8.1.1"
+
+[build-system]
+requires = ["poetry-core>=1.0.0"]
+build-backend = "poetry.core.masonry.api"