encommon 0.13.1__py3-none-any.whl → 0.15.0__py3-none-any.whl

encommon/colors/test/test_color.py

@@ -0,0 +1,189 @@
+"""
+Functions and routines associated with Enasis Network Common Library.
+
+This file is part of Enasis Network software eco-system. Distribution
+is permitted, for more information consult the project license file.
+"""
+
+
+
+from pytest import mark
+
+from ..color import Color
+from ...types import lattrs
+
+
+
+def test_Color() -> None:
+    """
+    Perform various tests associated with relevant routines.
+    """
+
+    color = Color('000001')
+
+
+    attrs = lattrs(color)
+
+    assert attrs == [
+        '_Color__source']
+
+
+    assert repr(color) == (
+        "Color('#000001')")
+
+    assert hash(color) > 0
+
+    assert str(color) == '#000001'
+
+
+    assert int(color) == 1
+    assert float(color) == 1.0
+
+    assert color + 1 == '000002'
+    assert color - 1 == '000000'
+
+    assert color == '000001'
+    assert color != '000000'
+    assert color != int
+
+    assert color > 0
+    assert color >= 1
+    assert color <= 1
+    assert color < 2
+
+    assert color > '000000'
+    assert color >= '000001'
+    assert color <= '000001'
+    assert color < '000002'
+
+
+
+@mark.parametrize(
+    'source,expect',
+    [('ff00cc', (255, 0, 204)),
+     ('ffffff', (255, 255, 255)),
+     ('000000', (0, 0, 0)),
+     ('ff0000', (255, 0, 0)),
+     ('00ff00', (0, 255, 0)),
+     ('0000ff', (0, 0, 255)),
+     ('808080', (128, 128, 128)),
+     ('ffff00', (255, 255, 0)),
+     ('00ffff', (0, 255, 255)),
+     ('ff00ff', (255, 0, 255)),
+     ('800080', (128, 0, 128))])
+def test_Color_rgb(
+    source: str,
+    expect: tuple[int, ...],
+) -> None:
+    """
+    Perform various tests associated with relevant routines.
+
+    :param source: Source color used when converting values.
+    :param expect: Expected output from the testing routine.
+    """
+
+    assert Color(source).rgb == expect
+
+
+
+@mark.parametrize(
+    'source,expect',
+    [('ff00cc', (52.1391, 25.6196, 59.3238)),
+     ('ffffff', (95.0500, 100.0000, 108.9000)),
+     ('000000', (0.0000, 0.0000, 0.0000)),
+     ('ff0000', (41.2400, 21.2600, 1.9300)),
+     ('00ff00', (35.7600, 71.5200, 11.9200)),
+     ('0000ff', (18.0500, 7.2200, 95.0500)),
+     ('808080', (20.5175, 21.5861, 23.5072)),
+     ('ffff00', (77.0000, 92.7800, 13.8500)),
+     ('00ffff', (53.8100, 78.7400, 106.9700)),
+     ('ff00ff', (59.2900, 28.4800, 96.9800)),
+     ('800080', (12.7984, 6.1477, 20.9342))])
+def test_Color_xyz(
+    source: str,
+    expect: tuple[int, ...],
+) -> None:
+    """
+    Perform various tests associated with relevant routines.
+
+    :param source: Source color used when converting values.
+    :param expect: Expected output from the testing routine.
+    """
+
+    assert Color(source).xyz == expect
+
+
+
+@mark.parametrize(
+    'source,expect',
+    [('ff00cc', (0.3803, 0.1869)),
+     ('ffffff', (0.3127, 0.3290)),
+     ('000000', (0.0000, 0.0000)),
+     ('ff0000', (0.6401, 0.3300)),
+     ('00ff00', (0.3000, 0.6000)),
+     ('0000ff', (0.1500, 0.0600)),
+     ('808080', (0.3127, 0.3290)),
+     ('ffff00', (0.4193, 0.5053)),
+     ('00ffff', (0.2247, 0.3287)),
+     ('ff00ff', (0.3209, 0.1542)),
+     ('800080', (0.3209, 0.1542))])
+def test_Color_xy(
+    source: str,
+    expect: tuple[int, ...],
+) -> None:
+    """
+    Perform various tests associated with relevant routines.
+
+    :param source: Source color used when converting values.
+    :param expect: Expected output from the testing routine.
+    """
+
+    assert Color(source).xy == expect
+
+
+
+@mark.parametrize(
+    'source,expect',
+    [('ff00cc', (312, 100, 50)),
+     ('ffffff', (0, 0, 100)),
+     ('000000', (0, 0, 0)),
+     ('ff0000', (0, 100, 50)),
+     ('00ff00', (120, 100, 50)),
+     ('0000ff', (240, 100, 50)),
+     ('808080', (0, 0, 50)),
+     ('ffff00', (60, 100, 50)),
+     ('00ffff', (180, 100, 50)),
+     ('ff00ff', (300, 100, 50)),
+     ('800080', (300, 100, 25))])
+def test_Color_hsl(
+    source: str,
+    expect: tuple[int, ...],
+) -> None:
+    """
+    Perform various tests associated with relevant routines.
+
+    :param source: Source color used when converting values.
+    :param expect: Expected output from the testing routine.
+    """
+
+    assert Color(source).hsl == expect
+
+
+
+def test_Color_cover() -> None:
+    """
+    Perform various tests associated with relevant routines.
+    """
+
+    color1 = Color('000001')
+    color2 = Color('#000001')
+
+    assert not (color1 > None)  # type: ignore
+    assert not (color1 >= None)  # type: ignore
+    assert not (color1 <= None)  # type: ignore
+    assert not (color1 < None)  # type: ignore
+
+    assert color1 - color2 == 0
+    assert color1 - '000001' == 0
+    assert color1 + color2 == 2
+    assert color1 + '000001' == 2

encommon/config/config.py

@@ -8,7 +8,6 @@ is permitted, for more information consult the project license file.
 
 
 from copy import deepcopy
-from typing import Any
 from typing import Callable
 from typing import Optional
 from typing import TYPE_CHECKING
@@ -19,6 +18,7 @@ from .params import Params
 from .paths import ConfigPaths
 from .utils import config_paths
 from ..crypts import Crypts
+from ..types import DictStrAny
 from ..types import merge_dicts
 from ..types import setate
 
@@ -55,8 +55,8 @@ class Config:
 
     __files: ConfigFiles
     __paths: ConfigPaths
-    __cargs: dict[str, Any]
-    __sargs: dict[str, Any]
+    __cargs: DictStrAny
+    __sargs: DictStrAny
 
     __model: Callable  # type: ignore
 
@@ -67,11 +67,11 @@ class Config:
 
     def __init__(
         self,
-        *,
         files: Optional['PATHABLE'] = None,
+        *,
         paths: Optional['PATHABLE'] = None,
-        cargs: Optional[dict[str, Any]] = None,
-        sargs: Optional[dict[str, Any]] = None,
+        cargs: Optional[DictStrAny] = None,
+        sargs: Optional[DictStrAny] = None,
         model: Optional[Callable] = None,  # type: ignore
     ) -> None:
         """
@@ -133,14 +133,14 @@ class Config:
     @property
     def cargs(
         self,
-    ) -> dict[str, Any]:
+    ) -> DictStrAny:
         """
         Return the value for the attribute from class instance.
 
         :returns: Value for the attribute from class instance.
         """
 
-        returned: dict[str, Any] = {}
+        returned: DictStrAny = {}
 
         cargs = deepcopy(self.__cargs)
 
@@ -155,14 +155,14 @@ class Config:
     @property
     def sargs(
         self,
-    ) -> dict[str, Any]:
+    ) -> DictStrAny:
         """
         Return the value for the attribute from class instance.
 
         :returns: Value for the attribute from class instance.
         """
 
-        returned: dict[str, Any] = {}
+        returned: DictStrAny = {}
 
         sargs = deepcopy(self.__sargs)
 
@@ -177,16 +177,71 @@ class Config:
     @property
     def config(
         self,
-    ) -> dict[str, Any]:
+    ) -> DictStrAny:
         """
-        Return the configuration in dictionary format for files.
+        Return the configuration dumped from the Pydantic model.
 
-        :returns: Configuration in dictionary format for files.
+        :returns: Configuration dumped from the Pydantic model.
         """
 
         return self.params.model_dump()
 
 
+    @property
+    def basic(
+        self,
+    ) -> DictStrAny:
+        """
+        Return the configuration source loaded from the objects.
+
+        :returns: Configuration source loaded from the objects.
+        """
+
+        files = self.files
+
+        ferged = files.merge
+
+        merge_dicts(
+            dict1=ferged,
+            dict2=self.cargs,
+            force=True)
+
+        return deepcopy(ferged)
+
+
+    @property
+    def merge(
+        self,
+    ) -> DictStrAny:
+        """
+        Return the configuration source loaded from the objects.
+
+        :returns: Configuration source loaded from the objects.
+        """
+
+        files = self.files
+        paths = self.paths
+
+        ferged = files.merge
+        perged = paths.merge
+
+        merge_dicts(
+            dict1=ferged,
+            dict2=self.cargs,
+            force=True)
+
+        values = perged.values()
+
+        for merge in values:
+
+            merge_dicts(
+                dict1=ferged,
+                dict2=merge,
+                force=False)
+
+        return deepcopy(ferged)
+
+
     @property
     def model(
         self,
@@ -215,20 +270,12 @@ class Config:
         if params is not None:
             return params
 
-
-        merged = self.files.merged
-
-        merge_dicts(
-            dict1=merged,
-            dict2=self.cargs,
-            force=True)
-
-        params = self.model(**merged)
-
+        params = self.model(
+            **self.basic)
 
         self.__params = params
 
-        return params
+        return self.__params
 
 
     @property
@@ -241,11 +288,14 @@ class Config:
         :returns: Instance of Python logging library created.
         """
 
-        if self.__logger is not None:
-            return self.__logger
+        logger = self.__logger
+        params = self.params
+
+        if logger is not None:
+            return logger
 
         logger = Logger(
-            self.params.enlogger)
+            params.enlogger)
 
         self.__logger = logger
 
@@ -262,11 +312,14 @@ class Config:
         :returns: Instance of the encryption instance created.
         """
 
-        if self.__crypts is not None:
-            return self.__crypts
+        crypts = self.__crypts
+        params = self.params
+
+        if crypts is not None:
+            return crypts
 
         crypts = Crypts(
-            self.params.encrypts)
+            params.encrypts)
 
         self.__crypts = crypts
 

encommon/config/files.py

@@ -9,14 +9,15 @@ is permitted, for more information consult the project license file.
 
 from copy import deepcopy
 from pathlib import Path
-from typing import Any
 from typing import Optional
 from typing import TYPE_CHECKING
 
 from .utils import config_load
 from .utils import config_path
 from .utils import config_paths
+from ..types import DictStrAny
 from ..types import merge_dicts
+from ..types import sort_dict
 
 if TYPE_CHECKING:
     from ..utils.common import PATHABLE
@@ -31,7 +32,7 @@ class ConfigFile:
     """
 
     path: Path
-    config: dict[str, Any]
+    config: DictStrAny
 
 
     def __init__(
@@ -61,7 +62,7 @@ class ConfigFiles:
     paths: tuple[Path, ...]
     config: dict[str, ConfigFile]
 
-    __merged: Optional[dict[str, Any]]
+    __merge: Optional[DictStrAny]
 
 
     def __init__(
@@ -79,13 +80,13 @@ class ConfigFiles:
             str(x): ConfigFile(x)
             for x in self.paths}
 
-        self.__merged = None
+        self.__merge = None
 
 
     @property
-    def merged(
+    def merge(
         self,
-    ) -> dict[str, Any]:
+    ) -> DictStrAny:
         """
         Return the configuration in dictionary format for files.
 
@@ -93,12 +94,12 @@ class ConfigFiles:
         """
 
         config = self.config
-        merged = self.__merged
+        merge = self.__merge
 
-        if merged is not None:
-            return deepcopy(merged)
+        if merge is not None:
+            return deepcopy(merge)
 
-        merged = {}
+        merge = {}
 
 
         for file in config.values():
@@ -106,11 +107,13 @@ class ConfigFiles:
             source = file.config
 
             merge_dicts(
-                dict1=merged,
+                dict1=merge,
                 dict2=deepcopy(source),
                 force=False)
 
 
-        self.__merged = merged
+        merge = sort_dict(merge)
 
-        return deepcopy(merged)
+        self.__merge = merge
+
+        return deepcopy(merge)

encommon/config/logger.py

@@ -28,7 +28,7 @@ from typing import Optional
 from typing import TYPE_CHECKING
 
 from .utils import config_path
-from ..times import Times
+from ..times import Time
 from ..types import Empty
 from ..types.strings import COMMAD
 from ..types.strings import COMMAS
@@ -83,7 +83,7 @@ class Message:
     """
 
     __level: LOGLEVELS
-    __time: Times
+    __time: Time
     __fields: dict[str, str] = {}
 
 
@@ -98,7 +98,7 @@ class Message:
         """
 
         self.__level = level
-        self.__time = Times(time)
+        self.__time = Time(time)
         self.__fields = {}
 
         items = kwargs.items()
@@ -122,6 +122,11 @@ class Message:
                 value = COMMAD.join(values)
 
 
+            if (isinstance(value, Time)
+                    and key == 'elapsed'):
+                value = value.since
+
+
             if (isinstance(value, float)
                     and key == 'elapsed'):
 
@@ -183,14 +188,14 @@ class Message:
     @property
     def time(
         self,
-    ) -> Times:
+    ) -> Time:
         """
         Return the value for the attribute from class instance.
 
         :returns: Value for the attribute from class instance.
         """
 
-        return Times(self.__time)
+        return Time(self.__time)
 
 
     @property

encommon/config/params.py

@@ -8,73 +8,89 @@ is permitted, for more information consult the project license file.
 
 
 from pathlib import Path
+from typing import Annotated
+from typing import Any
 from typing import Optional
 
-from pydantic import BaseModel
+from pydantic import Field
 
 from .logger import LOGLEVELS
 from ..crypts import CryptsParams
+from ..types import BaseModel
 
 
 
 class ConfigParams(BaseModel, extra='forbid'):
     """
     Process and validate the core configuration parameters.
-
-    :param paths: Complete or relative path to config paths.
-    :param data: Keyword arguments passed to Pydantic model.
-        Parameter is picked up by autodoc, please ignore.
     """
 
-    paths: Optional[list[str]] = None
+    paths: Annotated[
+        Optional[list[str]],
+        Field(None,
+              description='Location of configuration files',
+              min_length=1)]
 
 
 
 class LoggerParams(BaseModel, extra='forbid'):
     """
     Process and validate the core configuration parameters.
-
-    :param stdo_level: Minimum level for the message to pass.
-    :param file_level: Minimum level for the message to pass.
-    :param file_path: Enables writing to the filesystem path.
     """
 
-    stdo_level: Optional[LOGLEVELS] = None
-    file_level: Optional[LOGLEVELS] = None
-    file_path: Optional[str] = None
+    stdo_level: Annotated[
+        Optional[LOGLEVELS],
+        Field(None,
+              description='Minimum logging message level',
+              min_length=1)]
+
+    file_level: Annotated[
+        Optional[LOGLEVELS],
+        Field(None,
+              description='Minimum logging message level',
+              min_length=1)]
+
+    file_path: Annotated[
+        Optional[str],
+        Field(None,
+              description='Enable output to the log file',
+              min_length=1)]
 
 
     def __init__(
         self,
-        stdo_level: Optional[LOGLEVELS] = None,
-        file_level: Optional[LOGLEVELS] = None,
-        file_path: Optional[str | Path] = None,
+        /,
+        **data: Any,
     ) -> None:
         """
         Initialize instance for class using provided parameters.
         """
 
-        if file_path is not None:
-            file_path = str(file_path)
+        file_path = data.get('file_path')
 
-        super().__init__(
-            stdo_level=stdo_level,
-            file_level=file_level,
-            file_path=file_path)
+        if isinstance(file_path, Path):
+            data['file_path'] = str(file_path)
+
+        super().__init__(**data)
 
 
 
 class Params(BaseModel, extra='forbid'):
     """
     Process and validate the core configuration parameters.
-
-    :param enconfig: Configuration for the Config instance.
-    :param enlogger: Configuration for the Logger instance.
-    :param encrypts: Configuration for the Crypts instance.
-    :param data: Keyword arguments passed to Pydantic model.
-        Parameter is picked up by autodoc, please ignore.
     """
 
-    enconfig: Optional[ConfigParams] = None
-    enlogger: Optional[LoggerParams] = None
-    encrypts: Optional[CryptsParams] = None
+    enconfig: Annotated[
+        Optional[ConfigParams],
+        Field(None,
+              description='Parameters for Config instance')]
+
+    enlogger: Annotated[
+        Optional[LoggerParams],
+        Field(None,
+              description='Parameters for Logger instance')]
+
+    encrypts: Annotated[
+        Optional[CryptsParams],
+        Field(None,
+              description='Parameters for Crypts instance')]