encommon 0.10.0__tar.gz → 0.11.1__tar.gz

{encommon-0.10.0/encommon.egg-info → encommon-0.11.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: encommon
-Version: 0.10.0
+Version: 0.11.1
 Summary: Enasis Network Common Library
 License: MIT
 Classifier: Programming Language :: Python :: 3

{encommon-0.10.0 → encommon-0.11.1}/encommon/config/__init__.py

@@ -7,9 +7,6 @@ is permitted, for more information consult the project license file.
 
 
 
-from .common import config_load
-from .common import config_path
-from .common import config_paths
 from .config import Config
 from .files import ConfigFile
 from .files import ConfigFiles
@@ -20,6 +17,9 @@ from .params import LoggerParams
 from .params import Params
 from .paths import ConfigPath
 from .paths import ConfigPaths
+from .utils import config_load
+from .utils import config_path
+from .utils import config_paths
 
 
 

{encommon-0.10.0 → encommon-0.11.1}/encommon/config/config.py

@@ -13,11 +13,11 @@ from typing import Callable
 from typing import Optional
 from typing import TYPE_CHECKING
 
-from .common import config_paths
 from .files import ConfigFiles
 from .logger import Logger
 from .params import Params
 from .paths import ConfigPaths
+from .utils import config_paths
 from ..crypts import Crypts
 from ..types import merge_dicts
 from ..types import setate
@@ -35,6 +35,16 @@ class Config:
        Configuration loaded from files is validated with the
        Pydantic model :class:`encommon.config.Params`.
 
+    .. testsetup::
+       >>> from pathlib import Path
+       >>> path = str(getfixture('tmpdir'))
+
+    Example
+    -------
+    >>> config = Config()
+    >>> config.config
+    {'enconfig': None, 'enlogger': None, 'encrypts': None}
+
     :param files: Complete or relative path to config files.
     :param paths: Complete or relative path to config paths.
     :param cargs: Configuration arguments in dictionary form,
@@ -200,16 +210,17 @@ class Config:
     ) -> Logger:
         """
         Initialize the Python logging library using parameters.
+
+        :returns: Instance of Python logging library created.
         """
 
         if self.__logger is not None:
             return self.__logger
 
-        enlogger = (
+        logger = Logger(
             self.params.enlogger)
 
-        self.__logger = (
-            Logger(params=enlogger))
+        self.__logger = logger
 
         return self.__logger
 
@@ -220,15 +231,16 @@ class Config:
     ) -> Crypts:
         """
         Initialize the encryption instance using the parameters.
+
+        :returns: Instance of the encryption instance created.
         """
 
         if self.__crypts is not None:
             return self.__crypts
 
-        encrypts = (
+        crypts = Crypts(
             self.params.encrypts)
 
-        self.__crypts = (
-            Crypts(params=encrypts))
+        self.__crypts = crypts
 
         return self.__crypts

{encommon-0.10.0 → encommon-0.11.1}/encommon/config/files.py

@@ -13,9 +13,9 @@ from typing import Any
 from typing import Optional
 from typing import TYPE_CHECKING
 
-from .common import config_load
-from .common import config_path
-from .common import config_paths
+from .utils import config_load
+from .utils import config_path
+from .utils import config_paths
 from ..types import merge_dicts
 
 if TYPE_CHECKING:

{encommon-0.10.0 → encommon-0.11.1}/encommon/config/logger.py

@@ -7,6 +7,7 @@ is permitted, for more information consult the project license file.
 
 
 
+from copy import deepcopy
 from json import dumps
 from logging import CRITICAL
 from logging import DEBUG
@@ -26,8 +27,7 @@ from typing import Literal
 from typing import Optional
 from typing import TYPE_CHECKING
 
-from .common import LOGLEVELS
-from .common import config_path
+from .utils import config_path
 from ..times import Times
 from ..types import Empty
 from ..types.strings import COMMAD
@@ -45,6 +45,13 @@ if TYPE_CHECKING:
 LOGR_FILE = 'encommon.logger.file'
 LOGR_STDO = 'encommon.logger.stdo'
 
+LOGLEVELS = Literal[
+    'critical',
+    'debug',
+    'error',
+    'info',
+    'warning']
+
 LOGSEVERS = {
     'critical': int(CRITICAL),
     'debug': int(DEBUG),
@@ -270,6 +277,7 @@ class FileFormatter(Formatter):
         Specifically overrides method for formatting exceptions.
 
         :param ei: Exception information provided by the logger.
+        :returns: String representation for the filesystem path.
         """
 
         reason = super().formatException(ei)
@@ -316,6 +324,8 @@ class Logger:
     :param params: Parameters for instantiating the instance.
     """
 
+    __params: 'LoggerParams'
+
     __stdo_level: Optional[LOGLEVELS]
     __file_level: Optional[LOGLEVELS]
     __file_path: Optional[Path]
@@ -328,20 +338,29 @@ class Logger:
 
     def __init__(
         self,
+        params: Optional['LoggerParams'] = None,
         *,
         stdo_level: Optional[LOGLEVELS] = None,
         file_level: Optional[LOGLEVELS] = None,
         file_path: Optional[str | Path] = None,
-        params: Optional['LoggerParams'] = None,
     ) -> None:
         """
         Initialize instance for class using provided parameters.
         """
 
-        if params is not None:
-            stdo_level = params.stdo_level
-            file_level = params.file_level
-            file_path = params.file_path
+        from .params import LoggerParams
+
+        if params is None:
+            params = LoggerParams(
+                stdo_level=stdo_level,
+                file_level=file_level,
+                file_path=file_path)
+
+        self.__params = deepcopy(params)
+
+        stdo_level = params.stdo_level
+        file_level = params.file_level
+        file_path = params.file_path
 
         if file_path is not None:
             file_path = config_path(file_path)
@@ -359,6 +378,19 @@ class Logger:
         self.__logr_file = logr_file
 
 
+    @property
+    def params(
+        self,
+    ) -> 'LoggerParams':
+        """
+        Return the Pydantic model containing the configuration.
+
+        :returns: Pydantic model containing the configuration.
+        """
+
+        return self.__params
+
+
     @property
     def stdo_level(
         self,

{encommon-0.10.0 → encommon-0.11.1}/encommon/config/params.py

@@ -7,11 +7,12 @@ is permitted, for more information consult the project license file.
 
 
 
+from pathlib import Path
 from typing import Optional
 
 from pydantic import BaseModel
 
-from .common import LOGLEVELS
+from .logger import LOGLEVELS
 from ..crypts import CryptsParams
 
 
@@ -45,6 +46,25 @@ class LoggerParams(BaseModel, extra='forbid'):
     file_path: Optional[str] = None
 
 
+    def __init__(
+        self,
+        stdo_level: Optional[LOGLEVELS] = None,
+        file_level: Optional[LOGLEVELS] = None,
+        file_path: Optional[str | Path] = None,
+    ) -> None:
+        """
+        Initialize instance for class using provided parameters.
+        """
+
+        if file_path is not None:
+            file_path = str(file_path)
+
+        super().__init__(
+            stdo_level=stdo_level,
+            file_level=file_level,
+            file_path=file_path)
+
+
 
 class Params(BaseModel, extra='forbid'):
     """

{encommon-0.10.0 → encommon-0.11.1}/encommon/config/paths.py

@@ -14,9 +14,9 @@ from typing import Any
 from typing import Optional
 from typing import TYPE_CHECKING
 
-from .common import config_path
-from .common import config_paths
 from .files import ConfigFile
+from .utils import config_path
+from .utils import config_paths
 
 if TYPE_CHECKING:
     from ..utils.common import PATHABLE

{encommon-0.10.0 → encommon-0.11.1}/encommon/config/test/test_logger.py

@@ -44,7 +44,7 @@ def logger(
         file_level='info',
         file_path=f'{tmp_path}/test.log')
 
-    return Logger(params=params)
+    return Logger(params)
 
 
 
@@ -142,6 +142,7 @@ def test_Logger(
     attrs = list(logger.__dict__)
 
     assert attrs == [
+        '_Logger__params',
         '_Logger__stdo_level',
         '_Logger__file_level',
         '_Logger__file_path',
@@ -161,6 +162,8 @@ def test_Logger(
         logger)
 
 
+    assert logger.params is not None
+
     assert logger.stdo_level == 'info'
 
     assert logger.file_level == 'info'

encommon-0.10.0/encommon/config/test/test_common.py → encommon-0.11.1/encommon/config/test/test_utils.py

@@ -7,9 +7,9 @@ is permitted, for more information consult the project license file.
 
 
 
-from ..common import config_load
-from ..common import config_path
-from ..common import config_paths
+from ..utils import config_load
+from ..utils import config_path
+from ..utils import config_paths
 from ... import PROJECT
 from ... import WORKSPACE
 

encommon-0.10.0/encommon/config/common.py → encommon-0.11.1/encommon/config/utils.py

@@ -9,7 +9,6 @@ is permitted, for more information consult the project license file.
 
 from pathlib import Path
 from typing import Any
-from typing import Literal
 from typing import Optional
 from typing import TYPE_CHECKING
 
@@ -28,15 +27,6 @@ if TYPE_CHECKING:
 
 
 
-LOGLEVELS = Literal[
-    'critical',
-    'debug',
-    'error',
-    'info',
-    'warning']
-
-
-
 def config_load(
     path: str | Path,
 ) -> dict[str, Any]:
@@ -90,6 +80,7 @@ def config_paths(
        This function simply wraps one from utils subpackage.
 
     :param paths: Complete or relative paths for processing.
+    :param replace: Optional values to replace in the path.
     :returns: New resolved filesystem path object instances.
     """
 

{encommon-0.10.0 → encommon-0.11.1}/encommon/conftest.py

@@ -38,7 +38,8 @@ def config_factory(
             '  stdo_level: info\n'
             'encrypts:\n'
             '  phrases:\n'
-            '    default: phrase\n'))
+            '    default:\n'
+            '      phrase: phrase\n'))
 
     config_log = f'{tmp_path}/config.log'
 

{encommon-0.10.0 → encommon-0.11.1}/encommon/crypts/crypts.py

@@ -7,6 +7,7 @@ is permitted, for more information consult the project license file.
 
 
 
+from copy import deepcopy
 from re import compile
 from re import match as re_match
 from re import sub as re_sub
@@ -18,6 +19,7 @@ from cryptography.fernet import Fernet
 from ..types.strings import SEMPTY
 
 if TYPE_CHECKING:
+    from .params import CryptParams
     from .params import CryptsParams
 
 
@@ -31,52 +33,54 @@ class Crypts:
     """
     Encrypt and decrypt values using passphrase dictionary.
 
+    .. testsetup::
+       >>> from .params import CryptsParams
+
     Example
     -------
     >>> phrase = Crypts.keygen()
-    >>> crypts = Crypts({'default': phrase})
+    >>> source = {'default': {'phrase': phrase}}
+    >>> params = CryptsParams(phrases=source)
+    >>> crypts = Crypts(params)
     >>> encrypt = crypts.encrypt('example')
+    >>> encrypt
+    '$ENCRYPT;1.0;default;...
     >>> crypts.decrypt(encrypt)
     'example'
 
-    :param phrases: Passphrases that are used in operations.
     :param params: Parameters for instantiating the instance.
     """
 
-    __phrases: dict[str, str]
+    __params: 'CryptsParams'
 
 
     def __init__(
         self,
-        phrases: Optional[dict[str, str]] = None,
         params: Optional['CryptsParams'] = None,
     ) -> None:
         """
         Initialize instance for class using provided parameters.
         """
 
-        phrases = phrases or {}
-
-        if params is not None:
-            phrases |= params.phrases
+        from .params import CryptsParams
 
-        if 'default' not in phrases:
-            raise ValueError('default')
+        if params is None:
+            params = CryptsParams()
 
-        self.__phrases = dict(phrases)
+        self.__params = deepcopy(params)
 
 
     @property
-    def phrases(
+    def params(
         self,
-    ) -> dict[str, str]:
+    ) -> 'CryptsParams':
         """
-        Return the value for the attribute from class instance.
+        Return the Pydantic model containing the configuration.
 
-        :returns: Value for the attribute from class instance.
+        :returns: Pydantic model containing the configuration.
         """
 
-        return dict(self.__phrases)
+        return self.__params
 
 
     def encrypt(
@@ -92,7 +96,12 @@ class Crypts:
         :returns: Encrypted value using the relevant passphrase.
         """
 
-        phrase = self.__phrases[unique]
+        phrases = self.params.phrases
+
+        if unique not in phrases:
+            raise ValueError('unique')
+
+        phrase = phrases[unique].phrase
 
         encrypt = (
             Fernet(phrase)
@@ -115,6 +124,8 @@ class Crypts:
         :returns: Decrypted value using the relevant passphrase.
         """
 
+        phrases = self.params.phrases
+
         value = crypt_clean(value)
 
         if not re_match(ENCRYPT, value):
@@ -126,7 +137,7 @@ class Crypts:
         if version != '1.0':
             raise ValueError('version')
 
-        phrase = self.__phrases[unique]
+        phrase = phrases[unique].phrase
 
         return (
             Fernet(phrase)
@@ -134,6 +145,44 @@ class Crypts:
             .decode())
 
 
+    def create(
+        self,
+        unique: str,
+        params: 'CryptParams',
+    ) -> None:
+        """
+        Create a new phrase using the provided input parameters.
+
+        :param unique: Unique identifier of mapping passphrase.
+        :param params: Parameters for instantiating the instance.
+        """
+
+        phrases = self.params.phrases
+
+        if unique in phrases:
+            raise ValueError('unique')
+
+        phrases[unique] = params
+
+
+    def delete(
+        self,
+        unique: str,
+    ) -> None:
+        """
+        Delete the phrase from the internal dictionary reference.
+
+        :param unique: Unique identifier of mapping passphrase.
+        """
+
+        phrases = self.params.phrases
+
+        if unique not in phrases:
+            raise ValueError('unique')
+
+        del phrases[unique]
+
+
     @classmethod
     def keygen(
         cls: object,
@@ -157,6 +206,7 @@ def crypt_clean(
     Return the parsed and normalized encrypted string value.
 
     :param value: String value that will returned decrypted.
+    :returns: Parsed and normalized encrypted string value.
     """
 
     return re_sub(r'[\n\s]', SEMPTY, value)

{encommon-0.10.0 → encommon-0.11.1}/encommon/crypts/params.py

@@ -11,6 +11,19 @@ from pydantic import BaseModel
 
 
 
+class CryptParams(BaseModel, extra='forbid'):
+    """
+    Process and validate the core configuration parameters.
+
+    :param phrase: Passphrases that are used in operations.
+    :param data: Keyword arguments passed to Pydantic model.
+        Parameter is picked up by autodoc, please ignore.
+    """
+
+    phrase: str
+
+
+
 class CryptsParams(BaseModel, extra='forbid'):
     """
     Process and validate the core configuration parameters.
@@ -20,4 +33,4 @@ class CryptsParams(BaseModel, extra='forbid'):
         Parameter is picked up by autodoc, please ignore.
     """
 
-    phrases: dict[str, str]
+    phrases: dict[str, CryptParams] = {}

{encommon-0.10.0 → encommon-0.11.1}/encommon/crypts/test/test_crypts.py

@@ -7,11 +7,14 @@ is permitted, for more information consult the project license file.
 
 
 
+from typing import Any
+
 from pytest import fixture
 from pytest import mark
 from pytest import raises
 
 from ..crypts import Crypts
+from ..params import CryptParams
 from ..params import CryptsParams
 from ...types import inrepr
 from ...types import instr
@@ -26,14 +29,14 @@ def crypts() -> Crypts:
     :returns: Newly constructed instance of related class.
     """
 
-    phrases = {
-        'default': Crypts.keygen(),
-        'secrets': Crypts.keygen()}
+    source: dict[str, Any] = {
+        'default': {'phrase': Crypts.keygen()},
+        'secrets': {'phrase': Crypts.keygen()}}
 
     params = CryptsParams(
-        phrases=phrases)
+        phrases=source)
 
-    return Crypts(params=params)
+    return Crypts(params)
 
 
 
@@ -50,7 +53,7 @@ def test_Crypts(
     attrs = list(crypts.__dict__)
 
     assert attrs == [
-        '_Crypts__phrases']
+        '_Crypts__params']
 
 
     assert inrepr(
@@ -64,7 +67,7 @@ def test_Crypts(
         crypts)
 
 
-    assert len(crypts.phrases) == 2
+    assert crypts.params is not None
 
     assert len(crypts.keygen()) == 44
 
@@ -101,6 +104,28 @@ def test_Crypts_iterate(
 
 
 
+def test_Crypts_cover(
+    crypts: Crypts,
+) -> None:
+    """
+    Perform various tests associated with relevant routines.
+
+    :param crypts: Primary class instance for the encryption.
+    """
+
+
+    crypts = Crypts()
+
+
+    params = CryptParams(
+        phrase=Crypts.keygen())
+
+    crypts.create('testing', params)
+
+    crypts.delete('testing')
+
+
+
 def test_Crypts_raises(
     crypts: Crypts,
 ) -> None:
@@ -114,15 +139,11 @@ def test_Crypts_raises(
     _raises = raises(ValueError)
 
     with _raises as reason:
-        Crypts({'foo': 'bar'})
+        crypts.encrypt('foo', 'dne')
 
     _reason = str(reason.value)
 
-    assert _reason == 'default'
-
-
-    crypts = Crypts(
-        crypts.phrases)
+    assert _reason == 'unique'
 
 
     _raises = raises(ValueError)
@@ -144,3 +165,25 @@ def test_Crypts_raises(
     _reason = str(reason.value)
 
     assert _reason == 'version'
+
+
+    _raises = raises(ValueError)
+
+    params = CryptParams(phrase='foo')
+
+    with _raises as reason:
+        crypts.create('default', params)
+
+    _reason = str(reason.value)
+
+    assert _reason == 'unique'
+
+
+    _raises = raises(ValueError)
+
+    with _raises as reason:
+        crypts.delete('dne')
+
+    _reason = str(reason.value)
+
+    assert _reason == 'unique'