Merge remote-tracking branch 'origin/0.6.0' into 283-create-rabbitmq-plugin

Author: albamig

packages/core/minos-microservice-aggregate/tests/test_aggregate/test_events/test_repositories/test_pg.py

@@ -44,7 +44,7 @@ def build_event_repository(self) -> EventRepository:
         return PostgreSqlEventRepository(**self.repository_db)
 
     def test_constructor(self):
-        repository = PostgreSqlEventRepository("host", 1234, "database", "user", "password")
+        repository = PostgreSqlEventRepository("database", "host", 1234, "user", "password")
         self.assertIsInstance(repository, EventRepository)
         self.assertEqual("host", repository.host)
         self.assertEqual(1234, repository.port)

packages/core/minos-microservice-aggregate/tests/test_aggregate/test_transactions/test_repositories/test_pg.py

@@ -43,7 +43,7 @@ async def test_subclass(self) -> None:
         self.assertTrue(issubclass(PostgreSqlTransactionRepository, TransactionRepository))
 
     def test_constructor(self):
-        repository = PostgreSqlTransactionRepository("host", 1234, "database", "user", "password")
+        repository = PostgreSqlTransactionRepository("database", "host", 1234, "user", "password")
         self.assertIsInstance(repository, PostgreSqlTransactionRepository)
         self.assertEqual("host", repository.host)
         self.assertEqual(1234, repository.port)

packages/core/minos-microservice-aggregate/tests/utils.py

@@ -73,20 +73,20 @@ def setUp(self) -> None:
                 self.snapshot_repository,
             ],
         )
-        self.injector.wire()
+        self.injector.wire_injections()
 
     async def asyncSetUp(self):
         await super().asyncSetUp()
 
-        await self.injector.setup()
+        await self.injector.setup_injections()
 
     async def asyncTearDown(self):
-        await self.injector.destroy()
+        await self.injector.destroy_injections()
 
         await super().asyncTearDown()
 
     def tearDown(self) -> None:
-        self.injector.unwire()
+        self.injector.unwire_injections()
         super().tearDown()
 
 

packages/core/minos-microservice-common/minos/common/__init__.py

@@ -3,11 +3,13 @@
 __version__ = "0.5.3"
 
 from .builders import (
+    BuildableMixin,
     Builder,
 )
 from .config import (
     Config,
     ConfigV1,
+    ConfigV2,
     MinosConfig,
 )
 from .database import (

packages/core/minos-microservice-common/minos/common/builders.py

@@ -4,12 +4,14 @@
 
 from abc import (
     ABC,
-    abstractmethod,
 )
 from typing import (
     Any,
     Generic,
+    Optional,
     TypeVar,
+    Union,
+    get_args,
 )
 
 from .config import (
@@ -25,25 +27,50 @@
 class Builder(SetupMixin, ABC, Generic[Instance]):
     """Builder class."""
 
-    def __init__(self, *args, **kwargs):
+    def __init__(self, instance_cls: Optional[type[Instance]] = None, *args, **kwargs):
+
         super().__init__(*args, **kwargs)
+        if instance_cls is None:
+            instance_cls = self._get_cls()
+
         self.kwargs = dict()
+        self.instance_cls = instance_cls
+
+    def _get_cls(self) -> Optional[type]:
+        # noinspection PyUnresolvedReferences
+        bases = self.__orig_bases__
+
+        instance_cls = get_args(next((base for base in bases if len(get_args(base))), None))[0]
+
+        if not isinstance(instance_cls, type):
+            return None
+
+        return instance_cls
 
     def copy(self: type[B]) -> B:
         """Get a copy of the instance.
 
-        :return: A ``BrokerSubscriberBuilder`` instance.
+        :return: A ``Builder`` instance.
         """
-        return self.new().with_kwargs(self.kwargs)
+        return self.new().with_cls(self.instance_cls).with_kwargs(self.kwargs)
 
     @classmethod
     def new(cls: type[B]) -> B:
         """Get a new instance.
 
-        :return: A ``BrokerSubscriberBuilder`` instance.
+        :return: A ``Builder`` instance.
         """
         return cls()
 
+    def with_cls(self: B, cls: type) -> B:
+        """Set class to be built.
+
+        :param cls: The class to be set.
+        :return: This method return the builder instance.
+        """
+        self.instance_cls = cls
+        return self
+
     def with_kwargs(self: B, kwargs: dict[str, Any]) -> B:
         """Set kwargs.
 
@@ -62,12 +89,58 @@ def with_config(self: B, config: Config) -> B:
         """
         return self
 
-    @abstractmethod
     def build(self) -> Instance:
         """Build the instance.
 
-        :return: A ``BrokerSubscriber`` instance.
+        :return: A ``Instance`` instance.
         """
+        return self.instance_cls(**self.kwargs)
+
+    def __eq__(self, other: Any) -> bool:
+        return isinstance(other, type(self)) and self.instance_cls == other.instance_cls and self.kwargs == other.kwargs
+
+    def __repr__(self) -> str:
+        return f"{type(self).__name__}({self.instance_cls.__name__}, {self.kwargs!r})"
+
+
+Ins = TypeVar("Ins", bound="BuildableMixin")
+
+
+class BuildableMixin(SetupMixin):
+    """Buildable Mixin class."""
+
+    _builder: Union[Builder[Ins], type[Builder[Ins]]] = Builder
+
+    @classmethod
+    def _from_config(cls, config: Config, **kwargs):
+        return cls.get_builder().with_config(config).with_kwargs(kwargs).build()
+
+    @classmethod
+    def set_builder(cls: type[Ins], builder: Union[Builder[Ins], type[Builder[Ins]]]) -> None:
+        """Set a builder class.
+
+        :param builder: The builder class to be set.
+        :return: This method does not return anything.
+        """
+        if not isinstance(builder, Builder) and not (isinstance(builder, type) and issubclass(builder, Builder)):
+            raise ValueError(f"Given builder value is invalid: {builder!r}")
+
+        cls._builder = builder
+
+    @classmethod
+    def get_builder(cls) -> Builder[Ins]:
+        """Get the builder class.
+
+        :return: A ``Builder`` instance.
+        """
+        builder = cls._builder
+
+        if isinstance(builder, Builder):
+            builder = builder.copy()
+        else:
+            builder = builder.new()
+
+        return builder.with_cls(cls)
 
 
 B = TypeVar("B", bound=Builder)

packages/core/minos-microservice-common/minos/common/config/__init__.py

@@ -5,3 +5,6 @@
 from .v1 import (
     ConfigV1,
 )
+from .v2 import (
+    ConfigV2,
+)

packages/core/minos-microservice-common/minos/common/config/abc.py

@@ -14,12 +14,16 @@
 from collections.abc import (
     Callable,
 )
+from contextlib import (
+    suppress,
+)
 from pathlib import (
     Path,
 )
 from typing import (
     TYPE_CHECKING,
     Any,
+    Optional,
     Union,
 )
 
@@ -40,16 +44,17 @@
         InjectableMixin,
     )
 
+sentinel = object()
+
 
 @Injectable("config")
 class Config(ABC):
     """Config base class."""
 
-    _PARAMETERIZED_MAPPER: dict = dict()
-    _ENVIRONMENT_MAPPER: dict = dict()
-
     __slots__ = ("_file_path", "_data", "_with_environment", "_parameterized")
 
+    DEFAULT_VALUES: dict[str, Any] = dict()
+
     def __init__(self, path: Union[Path, str], with_environment: bool = True, **kwargs):
         super().__init__()
         if isinstance(path, str):
@@ -68,11 +73,15 @@ def __new__(cls, *args, **kwargs) -> Config:
         from .v1 import (
             ConfigV1,
         )
+        from .v2 import (
+            ConfigV2,
+        )
 
         version_mapper = defaultdict(
             lambda: ConfigV1,
             {
                 1: ConfigV1,
+                2: ConfigV2,
             },
         )
 
@@ -185,6 +194,17 @@ def get_interfaces(self) -> dict[str, dict[str, Any]]:
     def _get_interfaces(self) -> dict[str, dict[str, Any]]:
         raise NotImplementedError
 
+    def get_pools(self) -> dict[str, type]:
+        """Get the pools value.
+
+        :return: A ``dict`` with pool names as keys and pools as values.
+        """
+        return self._get_pools()
+
+    @abstractmethod
+    def _get_pools(self) -> dict[str, type]:
+        raise NotImplementedError
+
     def get_routers(self) -> list[type]:
         """Get the routers value.
 
@@ -266,26 +286,54 @@ def get_by_key(self, key: str) -> Any:
         :param key: The key that identifies the value.
         :return: A value instance.
         """
-        if key in self._PARAMETERIZED_MAPPER and self._PARAMETERIZED_MAPPER[key] in self._parameterized:
-            return self._parameterized[self._PARAMETERIZED_MAPPER[key]]
 
-        if self._with_environment and key in self._ENVIRONMENT_MAPPER and self._ENVIRONMENT_MAPPER[key] in os.environ:
-            return os.environ[self._ENVIRONMENT_MAPPER[key]]
+        def _fn(k: str, data: dict[str, Any], previous: str = "", default: Optional[Any] = sentinel) -> Any:
+            current, _sep, following = k.partition(".")
+            full = f"{previous}.{current}".lstrip(".")
+
+            with suppress(KeyError):
+                return self._parameterized[self._to_parameterized_variable(full)]
+
+            if self._with_environment:
+                with suppress(KeyError):
+                    return os.environ[self._to_environment_variable(full)]
+
+            if default is not sentinel and current in default:
+                default_part = default[current]
+            else:
+                default_part = sentinel
 
-        def _fn(k: str, data: dict[str, Any]) -> Any:
-            current, _, following = k.partition(".")
+            if current not in data and default_part is not sentinel:
+                part = default_part
+            else:
+                part = data[current]
 
-            part = data[current]
-            if not following:
+            if following:
+                return _fn(following, part, full, default_part)
+
+            if not isinstance(part, dict):
                 return part
 
-            return _fn(following, part)
+            keys = part.keys()
+            if isinstance(default_part, dict):
+                keys |= default_part.keys()
+
+            result = dict()
+            for subpart in keys:
+                result[subpart] = _fn(subpart, part, full, default_part)
+            return result
 
         try:
-            return _fn(key, self._data)
+            return _fn(key, self._data, default=self.DEFAULT_VALUES)
         except Exception:
             raise MinosConfigException(f"{key!r} field is not defined on the configuration!")
 
+    def _to_parameterized_variable(self, key: str) -> str:
+        raise KeyError
+
+    def _to_environment_variable(self, key: str) -> str:
+        raise KeyError
+
 
 # noinspection PyUnusedLocal
 def _get_version(path: Union[str, Path], *args, **kwargs) -> int: