encommon 0.20.5__tar.gz → 0.22.0__tar.gz

encommon-0.22.0/MANIFEST.in

@@ -0,0 +1,10 @@
+
+
+
+include encommon/version.txt
+
+recursive-include encommon/webkit *.css
+recursive-include encommon/webkit *.html
+recursive-include encommon/webkit *.js
+recursive-include encommon/webkit *.png
+recursive-include encommon/webkit *.svg

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

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

{encommon-0.20.5 → encommon-0.22.0}/encommon/times/common.py

@@ -23,6 +23,9 @@ NUMERISH = compile(
 SNAPABLE = compile(
     r'^(\-|\+)[\d\@a-z\-\+]+$')
 
+UNITIME = Union[
+    int | float | str]
+
 STRINGNOW = {
     'None', None,
     'null', 'now'}

{encommon-0.20.5 → encommon-0.22.0}/encommon/times/unitime.py

@@ -7,14 +7,27 @@ is permitted, for more information consult the project license file.
 
 
 
+from re import compile
 from re import match as re_match
 
+from .common import UNITIME
 from .parse import since_time
 
 
 
+NOTATE = compile(
+    r'^(\d+(s|m|h|d|w|y))*$')
+
+STRINT = compile(
+    r'^\d+$')
+
+STRFLT = compile(
+    r'^\d+\.\d+$')
+
+
+
 def unitime(
-    input: int | float | str,
+    input: UNITIME,
 ) -> int:
     """
     Return the seconds in integer format for provided input.
@@ -32,20 +45,16 @@ def unitime(
     :returns: Seconds in integer format for provided input.
     """
 
-    notate = r'^(\d+(s|m|h|d|w|y))*$'
-    strint = r'^\d+$'
-    strflt = r'^\d+\.\d+$'
-
     if isinstance(input, str):
 
-        if re_match(notate, input):
+        if re_match(NOTATE, input):
             input = since_time(
                 'now', f'+{input}')
 
-        elif re_match(strint, input):
+        elif re_match(STRINT, input):
             input = int(input)
 
-        elif re_match(strflt, input):
+        elif re_match(STRFLT, input):
             input = int(
                 input.split('.')[0])
 

{encommon-0.20.5 → encommon-0.22.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.22.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.22.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.22.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.