encommon 0.20.5__tar.gz → 0.21.0__tar.gz

{encommon-0.20.5/encommon.egg-info → encommon-0.21.0}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.2
 Name: encommon
-Version: 0.20.5
+Version: 0.21.0
 Summary: Enasis Network Common Library
 License: MIT
 Project-URL: Source, https://github.com/enasisnetwork/encommon

{encommon-0.20.5 → encommon-0.21.0}/encommon/types/__init__.py

@@ -17,7 +17,9 @@ from .lists import dedup_list
 from .lists import fuzzy_list
 from .lists import inlist
 from .notate import delate
+from .notate import expate
 from .notate import getate
+from .notate import impate
 from .notate import setate
 from .strings import hasstr
 from .strings import inrepr
@@ -39,8 +41,10 @@ __all__ = [
     'delate',
     'DictStrAny',
     'Empty',
+    'expate',
     'getate',
     'hasstr',
+    'impate',
     'inlist',
     'inrepr',
     'instr',

{encommon-0.20.5 → encommon-0.21.0}/encommon/types/notate.py

@@ -193,6 +193,185 @@ def delate(
 
 
 
+def impate(  # noqa: CFQ001,CFQ004
+    source: DictStrAny | list[DictStrAny],
+    delim: str = '/',
+    parent: Optional[str] = None,
+    *,
+    implode_list: bool = True,
+    recurse_list: bool = True,
+) -> DictStrAny | list[DictStrAny]:
+    """
+    Implode the dictionary into a single depth of notation.
+
+    Example
+    -------
+    >>> impate({'foo': {'bar': 'baz'}})
+    {'foo/bar': 'baz'}
+
+    :param source: Dictionary object processed in notation.
+    :param delim: Override default delimiter between parts.
+    :param parent: Parent key prefix for downstream update.
+    :param implode_list: Determine whether list is imploded.
+    :param recurse_list: Determine whether flatten in list.
+    :returns: New dictionary that was recursively imploded.
+        It is also possible that a list of dictionary will
+        be returned when provided and implode_list is False.
+    """
+
+    _implode = implode_list
+    _recurse = recurse_list
+
+
+    def _proclist(
+        source: list[Any],
+        delim: str,
+        parent: Optional[str],
+    ) -> DictStrAny | list[Any]:
+
+
+        if _implode is False:
+
+            process = [
+                (impate(
+                    item, delim,
+                    implode_list=_implode,
+                    recurse_list=_recurse)
+                 if isinstance(item, dict | list)
+                 and _recurse is True
+                 else item)
+                for item in source]
+
+            return (
+                {parent: process}
+                if parent is not None
+                else process)
+
+
+        returned: DictStrAny = {}
+
+        for i, item in enumerate(source):
+
+            key = (
+                f'{parent}{delim}{i}'
+                if parent is not None
+                else str(i))
+
+            if (isinstance(item, dict | list)
+                    and _recurse is True):
+
+                implode = impate(
+                    item, delim, key,
+                    implode_list=_implode,
+                    recurse_list=_recurse)
+
+                assert isinstance(implode, dict)
+
+                returned.update(implode)
+
+            else:
+                returned[key] = item
+
+        return returned
+
+
+    def _procdict(
+        source: DictStrAny,
+        delim: str,
+        parent: Optional[str],
+    ) -> DictStrAny:
+
+        returned: DictStrAny = {}
+
+        for key, value in source.items():
+
+            key = (
+                f'{parent}{delim}{key}'
+                if parent is not None
+                else key)
+
+            if isinstance(value, dict):
+
+                implode = impate(
+                    value, delim, key,
+                    implode_list=_implode,
+                    recurse_list=_recurse)
+
+                assert isinstance(implode, dict)
+
+                returned |= implode
+
+            elif isinstance(value, list):
+
+                process = _proclist(
+                    value, delim, key)
+
+                returned |= (
+                    {key: process}
+                    if not isinstance(process, dict)
+                    else process)
+
+            else:
+                returned[key] = value
+
+        return returned
+
+
+    if isinstance(source, dict):
+        return _procdict(
+            source, delim, parent)
+
+    if isinstance(source, list):
+        return _proclist(
+            source, delim, parent)
+
+    raise ValueError('source')
+
+
+
+def expate(
+    source: DictStrAny,
+    delim: str = '/',
+) -> DictStrAny:
+    """
+    Explode the dictionary from a single depth of notation.
+
+    Example
+    -------
+    >>> expate({'foo/bar': 'baz'})
+    {'foo': {'bar': 'baz'}}
+
+    :param source: Dictionary object processed in notation.
+    :param delim: Override default delimiter between parts.
+    :returns: New dictionary that was recursively exploded.
+    """
+
+    returned: DictStrAny = {}
+
+
+    items = source.items()
+
+    for key, value in items:
+
+        if isinstance(value, list):
+            value = [
+                (expate(x, delim)
+                 if isinstance(x, dict)
+                 else x)
+                for x in value]
+
+        if isinstance(value, dict):
+            value = expate(value, delim)
+
+        setate(
+            returned, key,
+            value, delim)
+
+
+    return returned
+
+
+
 def _setpath(
     source: _SETABLE,
     path: str,

{encommon-0.20.5 → encommon-0.21.0}/encommon/types/test/__init__.py

@@ -8,6 +8,13 @@ is permitted, for more information consult the project license file.
 
 
 from copy import deepcopy
+from pathlib import Path
+
+
+
+SAMPLES = (
+    Path(__file__).parent
+    / 'samples')
 
 
 

{encommon-0.20.5 → encommon-0.21.0}/encommon/types/test/test_dicts.py

@@ -140,6 +140,7 @@ def test_merge_dicts() -> None:  # noqa: CFQ001
     assert source is not _source
 
 
+
 def test_sort_dict() -> None:
     """
     Perform various tests associated with relevant routines.

encommon-0.21.0/encommon/types/test/test_notate.py

@@ -0,0 +1,478 @@
+"""
+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 copy import deepcopy
+from pathlib import Path
+
+from _pytest.python_api import RaisesContext
+
+from pytest import fixture
+from pytest import raises
+
+from . import SAMPLES
+from . import _DICT1R
+from ..notate import delate
+from ..notate import expate
+from ..notate import getate
+from ..notate import impate
+from ..notate import setate
+from ..types import DictStrAny
+from ...utils import load_sample
+from ...utils import prep_sample
+from ...utils.sample import ENPYRWS
+
+
+
+_SAMPLE = dict[str, DictStrAny]
+
+
+
+@fixture
+def sample_impate() -> _SAMPLE:
+    """
+    Construct the dictionary for use with downstream tests.
+
+    :returns: Newly constructed dictionary for use in tests.
+    """
+
+    recurse_implode = (
+        impate(
+            deepcopy(_DICT1R),
+            recurse_list=True,
+            implode_list=True))
+
+    assert isinstance(
+        recurse_implode, dict)
+
+    nocurse_noplode = (
+        impate(
+            deepcopy(_DICT1R),
+            recurse_list=False,
+            implode_list=False))
+
+    assert isinstance(
+        nocurse_noplode, dict)
+
+    recurse_noplode = (
+        impate(
+            deepcopy(_DICT1R),
+            recurse_list=True,
+            implode_list=False))
+
+    assert isinstance(
+        recurse_noplode, dict)
+
+    nocurse_implode = (
+        impate(
+            deepcopy(_DICT1R),
+            recurse_list=False,
+            implode_list=True))
+
+    assert isinstance(
+        nocurse_implode, dict)
+
+
+    return {
+        'recurse_implode': recurse_implode,
+        'nocurse_noplode': nocurse_noplode,
+        'recurse_noplode': recurse_noplode,
+        'nocurse_implode': nocurse_implode}
+
+
+
+@fixture
+def sample_expate(
+    sample_impate: _SAMPLE,
+) -> _SAMPLE:
+    """
+    Construct the dictionary for use with downstream tests.
+
+    :param sample_impate: Source dictionary for use in test.
+    :returns: Newly constructed dictionary for use in tests.
+    """
+
+    recurse_implode = (
+        sample_impate[
+            'recurse_implode'])
+
+    assert isinstance(
+        recurse_implode, dict)
+
+    nocurse_noplode = (
+        sample_impate[
+            'nocurse_noplode'])
+
+    assert isinstance(
+        nocurse_noplode, dict)
+
+    recurse_noplode = (
+        sample_impate[
+            'recurse_noplode'])
+
+    assert isinstance(
+        recurse_noplode, dict)
+
+    nocurse_implode = (
+        sample_impate[
+            'nocurse_implode'])
+
+    assert isinstance(
+        nocurse_implode, dict)
+
+    return {
+        'recurse_implode': (
+            expate(recurse_implode)),
+        'nocurse_noplode': (
+            expate(nocurse_noplode)),
+        'recurse_noplode': (
+            expate(recurse_noplode)),
+        'nocurse_implode': (
+            expate(nocurse_implode))}
+
+
+
+def test_getate() -> None:
+    """
+    Perform various tests associated with relevant routines.
+    """
+
+    source = deepcopy(_DICT1R)
+
+
+    value = getate(['1', 2], '1')
+    assert value == 2
+
+    value = getate((1, 2), '1')
+    assert value == 2
+
+    value = getate({'1': 2}, '1')
+    assert value == 2
+
+
+    path = 'recurse/dict/key'
+    value = getate(source, path)
+
+    assert value == 'd1dict'
+
+
+    path = 'recurse/list/0'
+    value = getate(source, path)
+
+    assert value == 'd1list'
+
+
+
+def test_getate_cover() -> None:
+    """
+    Perform various tests associated with relevant routines.
+    """
+
+    source = deepcopy(_DICT1R)
+
+
+    assert not getate({}, 'd/n/e')
+    assert not getate([], '0/n/e')
+
+
+    path = 'recurse/str/a'
+    value = getate(source, path)
+
+    assert value is None
+
+
+
+def test_setate() -> None:
+    """
+    Perform various tests associated with relevant routines.
+    """
+
+    source = deepcopy(_DICT1R)
+
+
+    path = 'list/1'
+    before = getate(source, path)
+    setate(source, path, 1)
+    after = getate(source, path)
+    assert after == 1
+    assert before is None
+
+
+    path = 'recurse/dict/key'
+    before = getate(source, path)
+    setate(source, path, 1)
+    after = getate(source, path)
+    assert after == 1
+    assert before == 'd1dict'
+
+
+    path = 'nested/0/dict/key'
+    before = getate(source, path)
+    setate(source, path, 1)
+    after = getate(source, path)
+    assert after == 1
+    assert before == 'd1dict'
+
+
+    path = 'recurse/list/0'
+    before = getate(source, path)
+    setate(source, path, 1)
+    after = getate(source, path)
+    assert after == 1
+    assert before == 'd1list'
+
+
+
+def test_setate_cover() -> None:
+    """
+    Perform various tests associated with relevant routines.
+    """
+
+    source = deepcopy(_DICT1R)
+
+
+    path = 'nested/1/dict/key'
+    before = getate(source, path)
+    setate(source, path, 1)
+    after = getate(source, path)
+    assert after == 1
+    assert before is None
+
+
+
+def test_setate_raises() -> None:
+    """
+    Perform various tests associated with relevant routines.
+    """
+
+    _raises: RaisesContext[
+        ValueError | IndexError]
+
+
+    _raises = raises(ValueError)
+
+    with _raises as reason:
+        setate(1, '1', 1)  # type: ignore
+
+    _reason = str(reason.value)
+
+    assert _reason == 'source'
+
+
+    _raises = raises(IndexError)
+
+    with _raises as reason:
+        setate([], '1', 1)
+
+    _reason = str(reason.value)
+
+    assert _reason == '1'
+
+
+
+def test_delate() -> None:
+    """
+    Perform various tests associated with relevant routines.
+    """
+
+    source = deepcopy(_DICT1R)
+
+
+    path = 'recurse/dict/key'
+    before = getate(source, path)
+    delate(source, path)
+    after = getate(source, path)
+    assert after is None
+    assert before == 'd1dict'
+
+
+    path = 'nested/0/dict/key'
+    before = getate(source, path)
+    delate(source, path)
+    after = getate(source, path)
+    assert after is None
+    assert before == 'd1dict'
+
+
+    path = 'recurse/list/0'
+    before = getate(source, path)
+    delate(source, path)
+    after = getate(source, path)
+    assert after is None
+    assert before == 'd1list'
+
+
+
+def test_delate_raises() -> None:
+    """
+    Perform various tests associated with relevant routines.
+    """
+
+
+    _raises = raises(ValueError)
+
+    with _raises as reason:
+        delate(1, '1')  # type: ignore
+
+    _reason = str(reason.value)
+
+    assert _reason == 'source'
+
+
+    _raises = raises(ValueError)
+
+    with _raises as reason:
+        delate({'a': 1}, 'a/1/c')
+
+    _reason = str(reason.value)
+
+    assert _reason == 'source'
+
+
+
+def test_impate(
+    tmp_path: Path,
+    sample_impate: _SAMPLE,
+    sample_expate: _SAMPLE,
+) -> None:
+    """
+    Perform various tests associated with relevant routines.
+
+    :param sample_impate: Source dictionary for use in test.
+    :param sample_expate: Source dictionary for use in test.
+    :param tmp_path: pytest object for temporal filesystem.
+    """
+
+    sample_path = (
+        SAMPLES / 'impate.json')
+
+    sample = load_sample(
+        path=sample_path,
+        update=ENPYRWS,
+        content=sample_impate)
+
+    expect = prep_sample(
+        content=sample_impate)
+
+    assert expect == sample
+
+
+
+def test_impate_cover(
+    tmp_path: Path,
+    sample_impate: _SAMPLE,
+    sample_expate: _SAMPLE,
+) -> None:
+    """
+    Perform various tests associated with relevant routines.
+
+    :param sample_impate: Source dictionary for use in test.
+    :param sample_expate: Source dictionary for use in test.
+    :param tmp_path: pytest object for temporal filesystem.
+    """
+
+
+    default = sample_impate[
+        'recurse_implode']
+
+    assert default == impate(default)
+
+
+    sample = 'recurse_noplode'
+
+    implode = impate(
+        [sample_expate[sample],
+         sample_expate[sample]],
+        implode_list=False,
+        recurse_list=True)
+
+    assert isinstance(implode, list)
+
+    assert implode[0] == (
+        sample_impate[sample])
+
+
+    source = {'foo': {'bar': 'baz'}}
+    expect = {'foo/bar': 'baz'}
+
+    assert impate(source) == expect
+
+
+
+def test_impate_raises() -> None:
+    """
+    Perform various tests associated with relevant routines.
+    """
+
+    _raises: RaisesContext[ValueError]
+
+
+    _raises = raises(ValueError)
+
+    with _raises as reason:
+        impate('foo')  # type: ignore
+
+    _reason = str(reason.value)
+
+    assert _reason == 'source'
+
+
+
+def test_expate(
+    tmp_path: Path,
+    sample_impate: _SAMPLE,
+    sample_expate: _SAMPLE,
+) -> None:
+    """
+    Perform various tests associated with relevant routines.
+
+    :param sample_impate: Source dictionary for use in test.
+    :param sample_expate: Source dictionary for use in test.
+    :param tmp_path: pytest object for temporal filesystem.
+    """
+
+    sample_path = (
+        SAMPLES / 'expate.json')
+
+    sample = load_sample(
+        path=sample_path,
+        update=ENPYRWS,
+        content=sample_expate)
+
+    expect = prep_sample(
+        content=sample_expate)
+
+    assert expect == sample
+
+
+
+def test_expate_cover(
+    tmp_path: Path,
+    sample_impate: _SAMPLE,
+    sample_expate: _SAMPLE,
+) -> None:
+    """
+    Perform various tests associated with relevant routines.
+
+    :param sample_impate: Source dictionary for use in test.
+    :param sample_expate: Source dictionary for use in test.
+    :param tmp_path: pytest object for temporal filesystem.
+    """
+
+
+    assert sample_expate == (
+        expate(sample_impate))
+
+
+    assert sample_expate == (
+        expate(sample_expate))
+
+
+    assert all(
+        x == _DICT1R for x in
+        sample_expate.values())

encommon-0.21.0/encommon/version.txt

@@ -0,0 +1 @@
+0.21.0

{encommon-0.20.5 → encommon-0.21.0/encommon.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.2
 Name: encommon
-Version: 0.20.5
+Version: 0.21.0
 Summary: Enasis Network Common Library
 License: MIT
 Project-URL: Source, https://github.com/enasisnetwork/encommon

encommon-0.20.5/encommon/types/test/test_notate.py

@@ -1,217 +0,0 @@
-"""
-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 copy import deepcopy
-
-from _pytest.python_api import RaisesContext
-
-from pytest import raises
-
-from . import _DICT1R
-from ..notate import delate
-from ..notate import getate
-from ..notate import setate
-
-
-
-def test_getate() -> None:
-    """
-    Perform various tests associated with relevant routines.
-    """
-
-    source = deepcopy(_DICT1R)
-
-
-    value = getate(['1', 2], '1')
-    assert value == 2
-
-    value = getate((1, 2), '1')
-    assert value == 2
-
-    value = getate({'1': 2}, '1')
-    assert value == 2
-
-
-    path = 'recurse/dict/key'
-    value = getate(source, path)
-
-    assert value == 'd1dict'
-
-
-    path = 'recurse/list/0'
-    value = getate(source, path)
-
-    assert value == 'd1list'
-
-
-
-def test_getate_cover() -> None:
-    """
-    Perform various tests associated with relevant routines.
-    """
-
-    source = deepcopy(_DICT1R)
-
-
-    assert not getate({}, 'd/n/e')
-    assert not getate([], '0/n/e')
-
-
-    path = 'recurse/str/a'
-    value = getate(source, path)
-
-    assert value is None
-
-
-
-def test_setate() -> None:
-    """
-    Perform various tests associated with relevant routines.
-    """
-
-    source = deepcopy(_DICT1R)
-
-
-    path = 'list/1'
-    before = getate(source, path)
-    setate(source, path, 1)
-    after = getate(source, path)
-    assert after == 1
-    assert before is None
-
-
-    path = 'recurse/dict/key'
-    before = getate(source, path)
-    setate(source, path, 1)
-    after = getate(source, path)
-    assert after == 1
-    assert before == 'd1dict'
-
-
-    path = 'nested/0/dict/key'
-    before = getate(source, path)
-    setate(source, path, 1)
-    after = getate(source, path)
-    assert after == 1
-    assert before == 'd1dict'
-
-
-    path = 'recurse/list/0'
-    before = getate(source, path)
-    setate(source, path, 1)
-    after = getate(source, path)
-    assert after == 1
-    assert before == 'd1list'
-
-
-
-def test_setate_cover() -> None:
-    """
-    Perform various tests associated with relevant routines.
-    """
-
-    source = deepcopy(_DICT1R)
-
-
-    path = 'nested/1/dict/key'
-    before = getate(source, path)
-    setate(source, path, 1)
-    after = getate(source, path)
-    assert after == 1
-    assert before is None
-
-
-
-def test_setate_raises() -> None:
-    """
-    Perform various tests associated with relevant routines.
-    """
-
-    _raises: RaisesContext[
-        ValueError | IndexError]
-
-
-    _raises = raises(ValueError)
-
-    with _raises as reason:
-        setate(1, '1', 1)  # type: ignore
-
-    _reason = str(reason.value)
-
-    assert _reason == 'source'
-
-
-    _raises = raises(IndexError)
-
-    with _raises as reason:
-        setate([], '1', 1)
-
-    _reason = str(reason.value)
-
-    assert _reason == '1'
-
-
-
-def test_delate() -> None:
-    """
-    Perform various tests associated with relevant routines.
-    """
-
-    source = deepcopy(_DICT1R)
-
-
-    path = 'recurse/dict/key'
-    before = getate(source, path)
-    delate(source, path)
-    after = getate(source, path)
-    assert after is None
-    assert before == 'd1dict'
-
-
-    path = 'nested/0/dict/key'
-    before = getate(source, path)
-    delate(source, path)
-    after = getate(source, path)
-    assert after is None
-    assert before == 'd1dict'
-
-
-    path = 'recurse/list/0'
-    before = getate(source, path)
-    delate(source, path)
-    after = getate(source, path)
-    assert after is None
-    assert before == 'd1list'
-
-
-
-def test_delate_raises() -> None:
-    """
-    Perform various tests associated with relevant routines.
-    """
-
-
-    _raises = raises(ValueError)
-
-    with _raises as reason:
-        delate(1, '1')  # type: ignore
-
-    _reason = str(reason.value)
-
-    assert _reason == 'source'
-
-
-    _raises = raises(ValueError)
-
-    with _raises as reason:
-        delate({'a': 1}, 'a/1/c')
-
-    _reason = str(reason.value)
-
-    assert _reason == 'source'

encommon-0.20.5/encommon/version.txt

@@ -1 +0,0 @@
-0.20.5