sincpro-framework 1.0.1__tar.gz

sincpro_framework-1.0.1/LICENSE.md

@@ -0,0 +1,61 @@
+Copyright (c) 2023 Sincpro S.R.L
+LICENCIA EMPRESARIAL DE USO DE SOFTWARE
+
+Términos y Condiciones
+
+1. Definiciones
+   
+   1.1. "Software" hace referencia a cualquier programa de computadora y su documentación relacionada desarrollados
+   por Sincpro Developers.
+
+   1.2. "Cliente" se refiere a cualquier entidad o individuo que obtiene una licencia para utilizar el Software bajo
+   los términos y condiciones establecidos en este documento.
+
+2. Concesión de Licencia
+   Sincpro Developers otorga al Cliente una licencia no exclusiva, no transferible y limitada para utilizar el Software
+   de acuerdo con los términos y condiciones establecidos en este documento.
+
+3. Propiedad y Derechos de Autor
+
+   3.1. El Software es propiedad exclusiva de Sincpro Developers y está protegido por leyes de derechos de autor y otras
+    leyes de propiedad intelectual.
+
+   3.2. El Cliente reconoce y acepta que no adquiere ningún derecho de propiedad sobre el Software, excepto los derechos
+   limitados otorgados por esta licencia.
+
+4. Alcance de Uso
+
+   4.1. El Cliente está autorizado a utilizar el Software únicamente para los fines y en la forma especificados en la
+   documentación proporcionada por Sincpro Developers.
+
+   4.2. El uso del Software por parte del Cliente está limitado al número de usuarios y ubicaciones geográficas
+   especificados en la documentación.
+
+5. Restricciones
+
+   5.1. Queda estrictamente prohibido al Cliente: (a) copiar, modificar o crear trabajos derivados del Software;
+   (b) sublicenciar, transferir o distribuir el Software a terceros;
+   (c) utilizar el Software de manera que infrinja las leyes aplicables.
+
+6. Sanciones y Consecuencias
+
+   6.1. El uso no autorizado o en violación de los términos de esta licencia puede resultar en acciones legales y
+   sanciones que Sincpro Developers considera necesarias y apropiadas.
+
+7. Protección Legal
+
+   7.1. Estos términos y condiciones están sujetos a las leyes y regulaciones aplicables. El Cliente acepta someterse
+   a la jurisdicción de los tribunales competentes en caso de disputa relacionada con el uso del Software.
+
+8. Cambios y Actualizaciones
+
+   8.1. Sincpro Developers se reserva el derecho de actualizar o modificar estos términos y condiciones en cualquier
+    momento. Dichos cambios serán efectivos a partir de la fecha de notificación al Cliente.
+
+9. Aceptación
+
+   9.1. Al utilizar el Software, el Cliente acepta y se compromete a cumplir con los términos y condiciones establecidos
+   en este documento.
+
+Para cualquier consulta sobre esta licencia o para solicitar permisos adicionales, comuníquese con Sincpro Developers
+en Bolivia, Cochabamba Mayor rocha #161 y ayacucho o informacion@sincpro.com.bo

sincpro_framework-1.0.1/PKG-INFO

@@ -0,0 +1,206 @@
+Metadata-Version: 2.1
+Name: sincpro-framework
+Version: 1.0.1
+Summary: Sincpro framework to use DDD, Clean architecture, Hexagonal architecture
+License: Copyright (c) 2023 Sincpro S.R.L
+Author: Gutierrez Andres
+Author-email: andru1236@gmail.com
+Requires-Python: >=3.10,<4.0
+Classifier: License :: Other/Proprietary License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Dist: dependency-injector (>=4.42.0,<5.0.0)
+Requires-Dist: logzero (>=1.7.0,<2.0.0)
+Description-Content-Type: text/markdown
+
+## Sincpro Framework (Application layer framework)
+
+The main goal of this framework is create a `proxy` and `facade` component/entity, using a pattern `bus` components that wraps all the application layer, allowing to the developer import all the business logic ready to be executed in any context
+
+### Main features:
+- Allow to inject `dependencies` provided by the user
+- Allow to inject `error handler` at the top level
+- Execute the business logic in a `bus` component only providing the DTO(`Data transfer object`)
+- Allow to execute decoupled (`use case`, `feature` , `business logic`)
+  - using the component `Feature` 
+- Allow to execute several `use cases` based on abstraction called `ApplicationService`
+  - This one contains the `feature bus` and the developer will be able to execute the `use case` in any context 
+
+#### Example usage
+
+#### Init the framework
+
+This framework provide a command bus that will provide to the developer register use cases
+
+- `Feature` -> This component will be used to execute decoupled business logic
+- `ApplicationService` -> This component has injected the `feature bus` and the developer will be able 
+to execute the registered `Feature`
+
+```python
+# Import the framework
+from sincpro_framework import (
+  UseFramework, 
+  ApplicationService, 
+  DataTransferObject,
+  Feature as _Feature
+)
+
+# Define exceptions this is optional but is a good practice
+class GlobalError(Exception): pass
+class AppServiceError(Exception): pass
+class FeatureError(Exception): pass
+
+
+# Some dependencies as function
+def call_print(algo):
+    print(f"Calling from closure {algo}")
+
+
+def global_error_handler(error):
+    """
+    Global layer to handle an error
+    This function will catch all the exceptions that were
+    raised 
+    """
+    if isinstance(error, GlobalError):
+        print("ERROR HANDLEADO")
+    else:
+        raise Exception("ERROR NO HANDLEADO")
+
+
+    
+def app_error_handler(error):
+    """
+    We add a handler for `application service` errors
+    """
+    if isinstance(error, AppServiceError):
+        print("APPLICATION HANDLER ERROR")
+        raise GlobalError("ERROR DESEDE APPLICATION")
+    else:
+        raise Exception("ERROR NO HANDLEADO")
+
+
+def feat_error_handler(error):
+    """
+    
+    """
+    if isinstance(error, FeatureError):
+        print("FEATURE HANDLER ERROR")
+        raise AppServiceError("ERROR DESEDE FEATURE")
+    else:
+        raise Exception("ERROR NO HANDLEADO")
+
+
+framework_sp = UseFramework()
+# You can add as many dependencies as you want
+# Also need to provide a name to the dependency, so in the context of the framework 
+# you will be able to call the injedted dependency
+framework_sp.add_dependency("andres", call_print)
+framework_sp.add_global_error_handler(global_error_handler)
+framework_sp.add_app_service_error_handler(app_error_handler)
+framework_sp.add_feature_error_handler(feat_error_handler)
+
+# -------------------------------------------- #
+# Buena practica en caso de querer tipar las injecciones de dependiencias
+# se sugiere crear una clase `Feature` o `ApplicationService` que hereden de las abtracciones
+# por ejemplo estamos importando `Feature` original pero como `_Feature` para no confundir
+from typing import TypeAlias
+class Feature(_Feature, ABC):
+    andres: TypeAlias = call_print
+    
+# de esta forma el IDE o editor nos ayudara a ver los tipos de las injecciones de dependencias
+# Recordar utilizar la clase Feature de este modulo en lugar de `sincpro_framework.Feature` ya que este contiene 
+# los tipos de las injecciones de dependencias y normalmente este contiene toda la configuracion 
+    
+```
+
+once you initialize the bus, you will be able to import the framework in your application layer
+
+this framework should be used in the `application layer`
+
+**pattern to import the framework** follow the next snippet 
+```python
+# Path file: src.apps.siat_api
+# Application layer main entry: __init__.py
+# import the initialized framework
+from src.apps.some_application.infrastructure.sp_framework import (
+    ApplicationService,
+    DataTransferObject,
+    Feature,
+    framework_sp,
+)
+
+# the `use_case` represent the application layer inside of it
+# you should find all the `Feature` and `ApplicationService`
+from .use_case import *
+
+# Require to export to be consumed for the infrastructure layer or the more external layer
+__all__ = [
+    "use_case",
+    "framework_sp",
+    "Feature",
+    "DataTransferObject",
+    "ApplicationService",
+]
+
+
+
+# then import the framework_sp from any another consumer
+```
+
+Once you have the framework imported you will be able to register the `use cases`(Features or ServiceApplication)
+
+```python
+
+from src.apps.some_application import framework_sp
+
+# -------------------------------------------- #
+#  Feature
+# -------------------------------------------- #
+
+@dataclass(kw_only=True)
+class CommandRegisterServiceConfiguration(DataTransferObject):
+    comm: str
+
+
+@dataclass(kw_only=True)
+class ResponseRegisterServiceConfiguration(DataTransferObject):
+    comm: str
+
+
+@framework_sp.feature(CommandRegisterServiceConfiguration)
+class RegisterServiceConfiguration(Feature):
+    def execute(
+        self, dto: CommandRegisterServiceConfiguration
+    ) -> ResponseRegisterServiceConfiguration:
+        raise FeatureError("EError de feature")
+        return ResponseRegisterServiceConfiguration(comm=dto.comm)
+
+# -------------------------------------------- #
+#  Application service
+# -------------------------------------------- #
+@dataclass(kw_only=True)
+class CommandRegisterServiceConfiguration2(DataTransferObject):
+    comm: str
+
+
+@dataclass(kw_only=True)
+class ResponseRegisterServiceConfiguration(DataTransferObject):
+    comm: str
+
+
+@framework_sp.app_service(CommandRegisterServiceConfiguration2)
+class RegisterServiceConfiguration(ApplicationService):
+    def execute(
+        self, dto: CommandRegisterServiceConfiguration2
+    ) -> ResponseRegisterServiceConfiguration:
+        self.andres("Hello") # -> Dependency injected by the user
+        self.feature_bus.execute(CommandRegisterServiceConfiguration(comm="Hello")) #-> Decoupled feature
+        raise AppServiceError("Testing Global error")
+        return ResponseRegisterServiceConfiguration(comm=dto.comm)
+
+
+
+```

sincpro_framework-1.0.1/README.md

@@ -0,0 +1,189 @@
+## Sincpro Framework (Application layer framework)
+
+The main goal of this framework is create a `proxy` and `facade` component/entity, using a pattern `bus` components that wraps all the application layer, allowing to the developer import all the business logic ready to be executed in any context
+
+### Main features:
+- Allow to inject `dependencies` provided by the user
+- Allow to inject `error handler` at the top level
+- Execute the business logic in a `bus` component only providing the DTO(`Data transfer object`)
+- Allow to execute decoupled (`use case`, `feature` , `business logic`)
+  - using the component `Feature` 
+- Allow to execute several `use cases` based on abstraction called `ApplicationService`
+  - This one contains the `feature bus` and the developer will be able to execute the `use case` in any context 
+
+#### Example usage
+
+#### Init the framework
+
+This framework provide a command bus that will provide to the developer register use cases
+
+- `Feature` -> This component will be used to execute decoupled business logic
+- `ApplicationService` -> This component has injected the `feature bus` and the developer will be able 
+to execute the registered `Feature`
+
+```python
+# Import the framework
+from sincpro_framework import (
+  UseFramework, 
+  ApplicationService, 
+  DataTransferObject,
+  Feature as _Feature
+)
+
+# Define exceptions this is optional but is a good practice
+class GlobalError(Exception): pass
+class AppServiceError(Exception): pass
+class FeatureError(Exception): pass
+
+
+# Some dependencies as function
+def call_print(algo):
+    print(f"Calling from closure {algo}")
+
+
+def global_error_handler(error):
+    """
+    Global layer to handle an error
+    This function will catch all the exceptions that were
+    raised 
+    """
+    if isinstance(error, GlobalError):
+        print("ERROR HANDLEADO")
+    else:
+        raise Exception("ERROR NO HANDLEADO")
+
+
+    
+def app_error_handler(error):
+    """
+    We add a handler for `application service` errors
+    """
+    if isinstance(error, AppServiceError):
+        print("APPLICATION HANDLER ERROR")
+        raise GlobalError("ERROR DESEDE APPLICATION")
+    else:
+        raise Exception("ERROR NO HANDLEADO")
+
+
+def feat_error_handler(error):
+    """
+    
+    """
+    if isinstance(error, FeatureError):
+        print("FEATURE HANDLER ERROR")
+        raise AppServiceError("ERROR DESEDE FEATURE")
+    else:
+        raise Exception("ERROR NO HANDLEADO")
+
+
+framework_sp = UseFramework()
+# You can add as many dependencies as you want
+# Also need to provide a name to the dependency, so in the context of the framework 
+# you will be able to call the injedted dependency
+framework_sp.add_dependency("andres", call_print)
+framework_sp.add_global_error_handler(global_error_handler)
+framework_sp.add_app_service_error_handler(app_error_handler)
+framework_sp.add_feature_error_handler(feat_error_handler)
+
+# -------------------------------------------- #
+# Buena practica en caso de querer tipar las injecciones de dependiencias
+# se sugiere crear una clase `Feature` o `ApplicationService` que hereden de las abtracciones
+# por ejemplo estamos importando `Feature` original pero como `_Feature` para no confundir
+from typing import TypeAlias
+class Feature(_Feature, ABC):
+    andres: TypeAlias = call_print
+    
+# de esta forma el IDE o editor nos ayudara a ver los tipos de las injecciones de dependencias
+# Recordar utilizar la clase Feature de este modulo en lugar de `sincpro_framework.Feature` ya que este contiene 
+# los tipos de las injecciones de dependencias y normalmente este contiene toda la configuracion 
+    
+```
+
+once you initialize the bus, you will be able to import the framework in your application layer
+
+this framework should be used in the `application layer`
+
+**pattern to import the framework** follow the next snippet 
+```python
+# Path file: src.apps.siat_api
+# Application layer main entry: __init__.py
+# import the initialized framework
+from src.apps.some_application.infrastructure.sp_framework import (
+    ApplicationService,
+    DataTransferObject,
+    Feature,
+    framework_sp,
+)
+
+# the `use_case` represent the application layer inside of it
+# you should find all the `Feature` and `ApplicationService`
+from .use_case import *
+
+# Require to export to be consumed for the infrastructure layer or the more external layer
+__all__ = [
+    "use_case",
+    "framework_sp",
+    "Feature",
+    "DataTransferObject",
+    "ApplicationService",
+]
+
+
+
+# then import the framework_sp from any another consumer
+```
+
+Once you have the framework imported you will be able to register the `use cases`(Features or ServiceApplication)
+
+```python
+
+from src.apps.some_application import framework_sp
+
+# -------------------------------------------- #
+#  Feature
+# -------------------------------------------- #
+
+@dataclass(kw_only=True)
+class CommandRegisterServiceConfiguration(DataTransferObject):
+    comm: str
+
+
+@dataclass(kw_only=True)
+class ResponseRegisterServiceConfiguration(DataTransferObject):
+    comm: str
+
+
+@framework_sp.feature(CommandRegisterServiceConfiguration)
+class RegisterServiceConfiguration(Feature):
+    def execute(
+        self, dto: CommandRegisterServiceConfiguration
+    ) -> ResponseRegisterServiceConfiguration:
+        raise FeatureError("EError de feature")
+        return ResponseRegisterServiceConfiguration(comm=dto.comm)
+
+# -------------------------------------------- #
+#  Application service
+# -------------------------------------------- #
+@dataclass(kw_only=True)
+class CommandRegisterServiceConfiguration2(DataTransferObject):
+    comm: str
+
+
+@dataclass(kw_only=True)
+class ResponseRegisterServiceConfiguration(DataTransferObject):
+    comm: str
+
+
+@framework_sp.app_service(CommandRegisterServiceConfiguration2)
+class RegisterServiceConfiguration(ApplicationService):
+    def execute(
+        self, dto: CommandRegisterServiceConfiguration2
+    ) -> ResponseRegisterServiceConfiguration:
+        self.andres("Hello") # -> Dependency injected by the user
+        self.feature_bus.execute(CommandRegisterServiceConfiguration(comm="Hello")) #-> Decoupled feature
+        raise AppServiceError("Testing Global error")
+        return ResponseRegisterServiceConfiguration(comm=dto.comm)
+
+
+
+```

sincpro_framework-1.0.1/pyproject.toml

@@ -0,0 +1,43 @@
+[tool.poetry]
+name = "sincpro-framework"
+version = "1.0.1"
+description = "Sincpro framework to use DDD, Clean architecture, Hexagonal architecture"
+authors = ["Gutierrez Andres <andru1236@gmail.com>"]
+readme = "README.md"
+packages = [{include = "sincpro_framework"}]
+license = "Copyright (c) 2023 Sincpro S.R.L"
+
+[tool.poetry.dependencies]
+python = "^3.10"
+logzero = "^1.7.0"
+dependency-injector = "^4.42.0"
+
+
+[tool.poetry.group.dev.dependencies]
+isort = "^5.12.0"
+black = "^24.8.0"
+pytest = "^8.3.3"
+ipython = "^8.28.0"
+autoflake = "^2.3.1"
+
+[build-system]
+requires = ["poetry-core"]
+build-backend = "poetry.core.masonry.api"
+
+[tool.pylint]
+disable = [
+    "missing-docstring",
+    "fixme",
+    "C0103",
+    "C0301",
+    "R0903",
+    "C0413",
+    "W1203",
+    "I1101",
+    "W1309",
+    "R0902",
+    "C0415",
+]
+
+[tool.black]
+line-length = 94

sincpro_framework-1.0.1/sincpro_framework/__init__.py

@@ -0,0 +1,3 @@
+from .sincpro_abstractions import ApplicationService, DataTransferObject, Feature
+from .sincpro_logger import logger
+from .use_bus import UseFramework

sincpro_framework-1.0.1/sincpro_framework/bus.py

@@ -0,0 +1,128 @@
+from typing import Callable, Optional
+
+from .exceptions import DTOAlreadyRegistered, UnknownDTOToExecute
+from .sincpro_abstractions import ApplicationService, Bus, DataTransferObject, Feature
+from .sincpro_logger import logger
+
+
+class FeatureBus(Bus):
+    def __init__(self):
+        self.feature_registry = dict()
+        self.handle_error: Optional[Callable] = None
+
+    def register_feature(self, dto: DataTransferObject, feature: Feature) -> bool:
+        if dto.__name__ in self.feature_registry:
+            raise DTOAlreadyRegistered(
+                f"Data transfer object {dto.__name__} is already registered"
+            )
+
+        logger.info("Registering feature")
+        self.feature_registry[dto.__name__] = feature
+        return True
+
+    def execute(self, dto: DataTransferObject) -> DataTransferObject:
+        logger.info(f"Executing feature dto: [{dto.__class__.__name__}]")
+        logger.debug(f"{dto}")
+
+        try:
+            response = self.feature_registry[dto.__class__.__name__].execute(dto)
+            logger.debug(f"{response}")
+            return response
+
+        except Exception as error:
+            if self.handle_error:
+                return self.handle_error(error)
+
+            logger.error(str(error), exc_info=True)
+            raise error
+
+
+class ApplicationServiceBus(Bus):
+    def __init__(self):
+        self.app_service_registry = dict()
+        self.handle_error: Optional[Callable] = None
+
+    def register_app_service(
+        self, dto: DataTransferObject, app_service: ApplicationService
+    ) -> bool:
+        if dto.__name__ in self.app_service_registry:
+            raise DTOAlreadyRegistered(
+                f"Data transfer object {dto.__name__} is already registered"
+            )
+
+        logger.info("Registering application service")
+        self.app_service_registry[dto.__name__] = app_service
+        return True
+
+    def execute(self, dto: DataTransferObject) -> DataTransferObject:
+        logger.info(f"Executing app service dto: [{dto.__class__.__name__}]")
+        logger.debug(f"{dto}")
+        try:
+            response = self.app_service_registry[dto.__class__.__name__].execute(dto)
+            logger.debug(f"{response}")
+            return response
+
+        except Exception as error:
+            if self.handle_error:
+                return self.handle_error(error)
+
+            logger.error(str(error), exc_info=True)
+            raise error
+
+
+# ---------------------------------------------------------------------------------------------
+# Pattern Facade bus
+# ---------------------------------------------------------------------------------------------
+class FrameworkBus(Bus):
+    def __init__(self, feature_bus: FeatureBus, app_service_bus: ApplicationServiceBus):
+        self.feature_bus = feature_bus
+        self.app_service_bus = app_service_bus
+        self.handle_error: Optional[Callable] = None
+
+        registered_features = set(self.feature_bus.feature_registry.keys())
+        registered_app_services = set(self.app_service_bus.app_service_registry.keys())
+        logger.debug("Framework bus created")
+        logger.debug(f"Registered features: {registered_features}")
+        logger.debug(f"Registered app services: {registered_app_services}")
+
+        intersection_dtos = registered_features.intersection(registered_app_services)
+        if intersection_dtos:
+            logger.error(
+                f"Features and app services have the same name: {registered_features.intersection(registered_app_services)}"
+            )
+            raise DTOAlreadyRegistered(
+                f"Data transfer object {intersection_dtos} is present in application services and features, Change "
+                f"the name of the feature or create another framework instance to handle in doupled wat"
+            )
+
+    def execute(self, dto: DataTransferObject) -> DataTransferObject:
+        try:
+            dto_name = dto.__class__.__name__
+
+            if (
+                dto_name in self.app_service_bus.app_service_registry
+                and dto_name in self.feature_bus.feature_registry
+            ):
+                raise DTOAlreadyRegistered(
+                    f"Data transfer object {dto_name} is present in application services and features, Change the "
+                    f"name of the feature or create another framework instance to handle in doupled wat"
+                )
+            if dto_name in self.feature_bus.feature_registry:
+                response = self.feature_bus.execute(dto)
+                return response
+
+            if dto_name in self.app_service_bus.app_service_registry:
+                response = self.app_service_bus.execute(dto)
+                return response
+
+            raise UnknownDTOToExecute(
+                f"the DTO {dto_name} was not able to execute nothing review if the decorators are used properly, "
+                f"otherwise the DTO {dto_name} was never register using the decorator"
+            )
+
+        except Exception as error:
+            if self.handle_error:
+                return self.handle_error(error)
+
+            logger.error(str(error), exc_info=True)
+            raise error

sincpro_framework-1.0.1/sincpro_framework/exceptions.py

@@ -0,0 +1,14 @@
+class DTOAlreadyRegistered(Exception):
+    pass
+
+
+class DependencyAlreadyRegistered(Exception):
+    pass
+
+
+class UnknownDTOToExecute(Exception):
+    pass
+
+
+class SincproFrameworkNotBuilt(Exception):
+    pass

sincpro_framework-1.0.1/sincpro_framework/ioc.py

@@ -0,0 +1,109 @@
+from typing import Dict, Union
+
+from dependency_injector import containers, providers
+
+from .bus import ApplicationServiceBus, FeatureBus, FrameworkBus
+from .exceptions import DTOAlreadyRegistered
+from .sincpro_abstractions import ApplicationService, Feature
+from .sincpro_logger import logger
+
+# ---------------------------------------------------------------------------------------------
+# Container Definition
+# ---------------------------------------------------------------------------------------------
+
+
+class FrameworkContainer(containers.DynamicContainer):
+    injected_dependencies = providers.Dict()
+
+    # atomic layer
+    feature_registry: Dict[str, Feature] = providers.Dict({})
+    feature_bus: FeatureBus = providers.Factory(FeatureBus)
+
+    # orchestration layer
+    app_service_registry: Dict[str, ApplicationService] = providers.Dict({})
+    app_service_bus: ApplicationServiceBus = providers.Factory(
+        ApplicationServiceBus,
+    )
+
+    # Facade
+    framework_bus: FrameworkBus = providers.Factory(
+        FrameworkBus, feature_bus, app_service_bus
+    )
+
+
+# ---------------------------------------------------------------------------------------------
+# Build processes
+# ---------------------------------------------------------------------------------------------
+def inject_feature_to_bus(framework_container: FrameworkContainer, dto: Union[str, list]):
+    def inner_fn(decorated_class):
+        dtos = dto
+        if not isinstance(dto, list):
+            dtos = [dto]
+
+        for data_transfer_object in dtos:
+            if data_transfer_object.__name__ in framework_container.feature_registry.kwargs:
+                raise DTOAlreadyRegistered(
+                    f"The DTO: [{data_transfer_object.__name__} from {data_transfer_object.__module__}] is already registered"
+                )
+
+            logger.info(f"Registering feature: [{data_transfer_object.__name__}]")
+
+            # --------------------------------------------------------------------
+            # Register DTO to fn builder that will return the feature instance
+            framework_container.feature_registry = providers.Dict(
+                {
+                    **{
+                        data_transfer_object.__name__: providers.Factory(
+                            decorated_class,
+                        )
+                    },
+                    **framework_container.feature_registry.kwargs,
+                }
+            )
+
+            framework_container.feature_bus.add_attributes(
+                feature_registry=framework_container.feature_registry
+            )
+
+            return decorated_class
+
+    return inner_fn
+
+
+def inject_app_service_to_bus(framework_container: FrameworkContainer, dto: Union[str, list]):
+    def inner_fn(decorated_class):
+        dtos = dto
+        if not isinstance(dto, list):
+            dtos = [dto]
+
+        for data_transfer_object in dtos:
+            if (
+                data_transfer_object.__name__
+                in framework_container.app_service_registry.kwargs
+            ):
+                raise DTOAlreadyRegistered(
+                    f"The DTO: [{data_transfer_object.__name__} from {data_transfer_object.__module__}] is already registered"
+                )
+
+            logger.info(f"Registering application service: [{data_transfer_object.__name__}]")
+
+            # --------------------------------------------------------------------
+            # Register DTO to fn builder that will return the service instance
+            framework_container.app_service_registry = providers.Dict(
+                {
+                    **{
+                        data_transfer_object.__name__: providers.Factory(
+                            decorated_class, framework_container.feature_bus
+                        )
+                    },
+                    **framework_container.app_service_registry.kwargs,
+                }
+            )
+
+            framework_container.app_service_bus.add_attributes(
+                app_service_registry=framework_container.app_service_registry
+            )
+
+            return decorated_class
+
+    return inner_fn

sincpro_framework-1.0.1/sincpro_framework/sincpro_abstractions.py

@@ -0,0 +1,43 @@
+from abc import ABC, abstractmethod
+
+
+class DataTransferObject:
+    """
+    Abstraction that represent a object that will travel through to any layer
+    """
+
+
+class Bus(ABC):
+    @abstractmethod
+    def execute(self, dto: DataTransferObject) -> DataTransferObject:
+        """
+        :param dto:
+        :return:
+        """
+
+
+class Feature(ABC):
+    def __init__(self, *args, **kwargs):
+        pass
+
+    @abstractmethod
+    def execute(self, dto: DataTransferObject) -> DataTransferObject:
+        """
+        :param dto: Any command or event
+        :return:
+        """
+
+
+class ApplicationService(ABC):
+    feature_bus: Bus
+
+    def __init__(self, feature_bus: Bus, *args, **kwargs):
+        self.feature_bus = feature_bus
+
+    @abstractmethod
+    def execute(self, dto: DataTransferObject) -> DataTransferObject:
+        """
+        Main difference between Feature and ApplicationService can execute features internally
+        :param dto: Any command or event
+        :return: Any response
+        """

sincpro_framework-1.0.1/sincpro_framework/sincpro_logger.py

@@ -0,0 +1,14 @@
+import logging
+import os
+
+import logzero
+
+log_level = os.getenv("SP_FRAMEWORK_LOG_LEVEL", "DEBUG")
+log_output_file = os.getenv("SP_FRAMEWORK_LOG_OUTPUT_FILE", "/tmp/sp_framework.log")
+logzero.loglevel(log_level)
+
+if log_level == "DEBUG":
+    logzero.loglevel(logging.DEBUG)
+
+logzero.logfile(log_output_file)
+logger = logzero.logger

sincpro_framework-1.0.1/sincpro_framework/use_bus.py

@@ -0,0 +1,103 @@
+from functools import partial
+from typing import Any, Callable, Optional
+
+from . import ioc
+from .bus import FrameworkBus
+from .exceptions import DependencyAlreadyRegistered, SincproFrameworkNotBuilt
+from .sincpro_abstractions import DataTransferObject
+
+
+class UseFramework:
+    """
+    Main class to use the framework, this is the main entry point to configure the framework
+    """
+
+    def __init__(self):
+        self._sp_container = ioc.FrameworkContainer()
+        # Decorators
+        self.feature = partial(ioc.inject_feature_to_bus, self._sp_container)
+        self.app_service = partial(ioc.inject_app_service_to_bus, self._sp_container)
+
+        # Registry for dynamic dep injection
+        self.dynamic_dep_registry = dict()
+
+        # Error handlers
+        self.global_error_handler: Optional[Callable] = None
+        self.feature_error_handler: Optional[Callable] = None
+        self.app_service_error_handler: Optional[Callable] = None
+
+        self.was_initialized: bool = False
+        self.bus: Optional[FrameworkBus] = None
+
+    def __call__(self, dto: DataTransferObject) -> Optional[DataTransferObject]:
+        """
+        Main function to execute the framework
+        :param dto:
+        :return: Any response
+        """
+        if not self.was_initialized:
+            self._add_dependencies_provided_by_user()
+            self._add_error_handlers_provided_by_user()
+            self.was_initialized = True
+            self.bus: FrameworkBus = self._sp_container.framework_bus()
+
+        if self.bus is None:
+            raise SincproFrameworkNotBuilt(
+                "Check the decorators are rigistering the features and app services, check the imports of each "
+                "feature and app service"
+            )
+
+        return self.bus.execute(dto)
+
+    def add_dependency(self, name, dep: Any):
+        if name in self.dynamic_dep_registry:
+            raise DependencyAlreadyRegistered(f"The dependency {name} is already injected")
+        self.dynamic_dep_registry[name] = dep
+
+    def add_global_error_handler(self, handler: Callable):
+        if not callable(handler):
+            raise TypeError("The handler must be a callable")
+        self.global_error_handler = handler
+
+    def add_feature_error_handler(self, handler: Callable):
+        if not callable(handler):
+            raise TypeError("The handler must be a callable")
+        self.feature_error_handler = handler
+
+    def add_app_service_error_handler(self, handler: Callable):
+        if not callable(handler):
+            raise TypeError("The handler must be a callable")
+        self.app_service_error_handler = handler
+
+    def _add_dependencies_provided_by_user(self):
+        if "feature_registry" in self._sp_container.feature_bus.attributes:
+            feature_registry = self._sp_container.feature_bus.attributes[
+                "feature_registry"
+            ].kwargs
+
+            for dto, feature in feature_registry.items():
+                feature.add_attributes(**self.dynamic_dep_registry)
+
+        if "app_service_registry" in self._sp_container.app_service_bus.attributes:
+            app_service_registry = self._sp_container.app_service_bus.attributes[
+                "app_service_registry"
+            ].kwargs
+
+            for dto, app_service in app_service_registry.items():
+                app_service.add_attributes(**self.dynamic_dep_registry)
+
+    def _add_error_handlers_provided_by_user(self):
+        if self.global_error_handler:
+            self._sp_container.framework_bus.add_attributes(
+                handle_error=self.global_error_handler
+            )
+
+        if self.feature_error_handler:
+            self._sp_container.feature_bus.add_attributes(
+                handle_error=self.feature_error_handler
+            )
+
+        if self.app_service_error_handler:
+            self._sp_container.app_service_bus.add_attributes(
+                handle_error=self.app_service_error_handler
+            )