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

encommon/types/strings.py

@@ -21,22 +21,24 @@ SPACED = ' '
 
 
 
-def striplower(
-    value: str,
+def strplwr(
+    value: Any,  # noqa: ANN401
 ) -> str:
     """
     Return the provided string but stripped and lower cased.
 
     Example
     -------
-    >>> striplower('  Foo ')
+    >>> strplwr('  Foo ')
     'foo'
 
     :param value: String which will be stripped and lowered.
     :returns: Provided string but stripped and lower cased.
     """
 
-    return value.strip().lower()
+    _value = str(value)
+
+    return _value.strip().lower()
 
 
 
@@ -108,3 +110,26 @@ def instr(
     """
 
     return hasstr(str(haystack), needle)
+
+
+
+def rplstr(
+    source: str,
+    match: str,
+    value: Any,  # noqa: ANN401
+) -> str:
+    """
+    Return the source string with the match value replaced.
+
+    :param source: String that to be processed and returned.
+    :param match: What will be replaced within the string.
+    :param value: Replace value for the string is matched.
+    :returns: Source string with the match value replaced.
+    """
+
+    match = str(match)
+    value = str(value)
+
+    return (
+        str(source)
+        .replace(match, value))

encommon/types/test/test_classes.py

@@ -0,0 +1,74 @@
+"""
+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 typing import TYPE_CHECKING
+
+from ..classes import clsname
+from ..classes import lattrs
+from ...config import LoggerParams
+
+if TYPE_CHECKING:
+    from ...config import Config
+
+
+
+def test_BaseModel() -> None:
+    """
+    Perform various tests associated with relevant routines.
+    """
+
+    params = LoggerParams(
+        stdo_level='info')
+
+    dumped = params.model_dumped
+    pruned = params.model_pruned
+
+    assert dumped == {
+        'file_level': None,
+        'file_path': None,
+        'stdo_level': 'info'}
+
+    assert pruned == {
+        'stdo_level': 'info'}
+
+
+
+def test_clsname(
+    config: 'Config',
+) -> None:
+    """
+    Perform various tests associated with relevant routines.
+
+    :param config: Primary class instance for configuration.
+    """
+
+    assert clsname(config) == 'Config'
+
+
+
+def test_lattrs(
+    config: 'Config',
+) -> None:
+    """
+    Perform various tests associated with relevant routines.
+
+    :param config: Primary class instance for configuration.
+    """
+
+    attrs = lattrs(config)
+
+    assert attrs == [
+        '_Config__model',
+        '_Config__files',
+        '_Config__cargs',
+        '_Config__sargs',
+        '_Config__params',
+        '_Config__paths',
+        '_Config__logger',
+        '_Config__crypts']

encommon/types/test/test_lists.py

@@ -0,0 +1,23 @@
+"""
+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 ..lists import inlist
+
+
+
+def test_inlist() -> None:
+    """
+    Perform various tests associated with relevant routines.
+    """
+
+    needle = 123
+
+    haystack = [123, 456]
+
+    assert inlist(needle, haystack)

encommon/types/test/test_strings.py

@@ -10,16 +10,17 @@ is permitted, for more information consult the project license file.
 from ..strings import hasstr
 from ..strings import inrepr
 from ..strings import instr
-from ..strings import striplower
+from ..strings import rplstr
+from ..strings import strplwr
 
 
 
-def test_striplower() -> None:
+def test_strplwr() -> None:
     """
     Perform various tests associated with relevant routines.
     """
 
-    assert striplower(' Foo ') == 'foo'
+    assert strplwr(' Foo ') == 'foo'
 
 
 
@@ -59,3 +60,14 @@ def test_instr() -> None:
     item = MyClass()
 
     assert instr('MyClass', item)
+
+
+
+def test_rplstr() -> None:
+    """
+    Perform various tests associated with relevant routines.
+    """
+
+    string = rplstr('foo', 'o', 'O')
+
+    assert string == 'fOO'

encommon/types/types.py

@@ -0,0 +1,20 @@
+"""
+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 typing import Any
+
+
+
+DictStrAny = dict[str, Any]
+
+
+
+NCTrue = True
+NCFalse = False
+NCNone = None

encommon/utils/__init__.py

@@ -16,6 +16,8 @@ from .paths import resolve_paths
 from .paths import stats_path
 from .sample import load_sample
 from .sample import prep_sample
+from .sample import read_sample
+from .sample import rvrt_sample
 from .stdout import array_ansi
 from .stdout import kvpair_ansi
 from .stdout import make_ansi
@@ -32,7 +34,9 @@ __all__ = [
     'make_ansi',
     'prep_sample',
     'print_ansi',
+    'read_sample',
     'read_text',
+    'rvrt_sample',
     'resolve_path',
     'resolve_paths',
     'rgxp_match',

encommon/utils/paths.py

@@ -13,6 +13,7 @@ from typing import Optional
 from typing import TYPE_CHECKING
 
 from .match import rgxp_match
+from ..types import rplstr
 from ..types import sort_dict
 
 if TYPE_CHECKING:
@@ -50,13 +51,11 @@ def resolve_path(
 
         for old, new in items:
 
-            if isinstance(old, Path):
-                old = str(old)
+            old = str(old)
+            new = str(new)
 
-            if isinstance(new, Path):
-                new = str(new)
-
-            path = path.replace(old, new)
+            path = rplstr(
+                path, old, new)
 
     return Path(path).resolve()
 

encommon/utils/sample.py

@@ -7,54 +7,79 @@ is permitted, for more information consult the project license file.
 
 
 
+from dataclasses import asdict
+from dataclasses import is_dataclass
 from json import dumps
-from json import loads
+from os import environ
 from pathlib import Path
 from typing import Any
 from typing import Callable
 from typing import Optional
-from typing import TYPE_CHECKING
+
+from pydantic import BaseModel
 
 from .files import read_text
 from .files import save_text
+from ..types import rplstr
+
+
+
+PREFIX = 'encommon_sample'
 
-if TYPE_CHECKING:
-    from .common import REPLACE
+ENPYRWS = (
+    environ.get('ENPYRWS') == '1')
 
 
 
-def prep_sample(
+def prep_sample(  # noqa: CFQ004
     content: Any,
     *,
     default: Callable[[Any], str] = str,
-    replace: Optional['REPLACE'] = None,
-) -> Any:
-    """
-    Return the content after processing using JSON functions.
-
-    .. testsetup::
-       >>> from ..types import Empty
+    replace: Optional[dict[str, Any]] = None,
+    indent: Optional[int] = 2,
+) -> str:
+    r"""
+    Return the content after processing as the sample value.
 
     Example
     -------
     >>> prep_sample(['one', 'two'])
-    ['one', 'two']
+    '[\n  "one",\n  "two"\n]'
 
     Example
     -------
+    >>> from ..types import Empty
     >>> prep_sample({'one': Empty})
-    {'one': 'Empty'}
+    '{\n  "one": "Empty"\n}'
 
     :param content: Content that will be processed as JSON.
     :param default: Callable used when stringifying values.
     :param replace: Optional values to replace in the file.
-    :returns: Content after processing using JSON functions.
+    :returns: Content after processing as the sample value.
     """
 
-    content = dumps(
-        content, default=default)
 
-    prefix = 'encommon_sample'
+    def _default(
+        value: Any,  # noqa: ANN401
+    ) -> dict[str, Any] | str:
+
+        if is_dataclass(value):
+
+            assert not isinstance(
+                value, type)
+
+            return asdict(value)
+
+        if isinstance(value, BaseModel):
+            return value.model_dump()
+
+        return str(value)
+
+
+    content = dumps(
+        content,
+        default=_default,
+        indent=indent)
 
     replace = replace or {}
 
@@ -62,16 +87,14 @@ def prep_sample(
 
     for old, new in items:
 
-        if isinstance(old, Path):
-            old = str(old)
+        new = str(new)
 
-        if isinstance(new, Path):
-            new = str(new)
+        old = f'_/{PREFIX}/{old}/_'
 
-        content = content.replace(
-            new, f'_/{prefix}/{old}/_')
+        content = rplstr(
+            content, new, old)
 
-    return loads(content)
+    return str(content)
 
 
 
@@ -81,9 +104,9 @@ def load_sample(
     update: bool = False,
     *,
     default: Callable[[Any], str] = str,
-    replace: Optional['REPLACE'] = None,
-) -> Any:
-    """
+    replace: Optional[dict[str, Any]] = None,
+) -> str:
+    r"""
     Load the sample file and compare using provided content.
 
     .. testsetup::
@@ -96,14 +119,14 @@ def load_sample(
     -------
     >>> content = {'one': 'two'}
     >>> load_sample(sample, content)
-    {'one': 'two'}
+    '{\n  "one": "two"\n}'
 
     Example
     -------
     >>> load_sample(sample)
-    {'one': 'two'}
+    '{\n  "one": "two"\n}'
 
-    :param path: Complete or relative path for the sample.
+    :param path: Complete or relative path for sample file.
     :param update: Determine whether the sample is updated.
     :param content: Content that will be processed as JSON.
     :param default: Callable used when stringifying values.
@@ -111,6 +134,7 @@ def load_sample(
     :returns: Content after processing using JSON functions.
     """
 
+
     path = Path(path).resolve()
 
     loaded: Optional[Any] = None
@@ -123,18 +147,11 @@ def load_sample(
 
 
     def _save_sample() -> None:
-
-        dumped = dumps(
-            content, indent=2)
-
-        save_text(path, dumped)
+        save_text(path, content)
 
 
-    def _load_sample() -> Any:
-
-        loaded = read_text(path)
-
-        return loads(loaded)
+    def _load_sample() -> str:
+        return read_text(path)
 
 
     if path.exists():
@@ -150,3 +167,62 @@ def load_sample(
 
 
     return _load_sample()
+
+
+
+def read_sample(
+    sample: str,
+    *,
+    replace: Optional[dict[str, Any]] = None,
+    prefix: bool = True,
+) -> str:
+    """
+    Return the content after processing as the sample value.
+
+    :param sample: Content that will be processed as sample.
+    :param replace: Optional values to replace in the file.
+    :param prefix: Determine whether or not prefix is added.
+    :returns: Content after processing as the sample value.
+    """
+
+    replace = replace or {}
+
+    items = replace.items()
+
+    for new, old in items:
+
+        if prefix is True:
+            old = f'_/{PREFIX}/{old}/_'
+
+        sample = rplstr(
+            sample, new, old)
+
+    return str(sample)
+
+
+
+def rvrt_sample(
+    sample: str,
+    *,
+    replace: Optional[dict[str, Any]] = None,
+) -> str:
+    """
+    Return the content after processing as the sample value.
+
+    :param sample: Content that will be processed as sample.
+    :param replace: Optional values to replace in the file.
+    :returns: Content after processing as the sample value.
+    """
+
+    replace = replace or {}
+
+    items = replace.items()
+
+    for new, old in items:
+
+        new = f'_/{PREFIX}/{new}/_'
+
+        sample = rplstr(
+            sample, new, old)
+
+    return str(sample)

encommon/utils/stdout.py

@@ -7,23 +7,32 @@ is permitted, for more information consult the project license file.
 
 
 
+from dataclasses import asdict
 from dataclasses import dataclass
+from dataclasses import is_dataclass
 from re import compile
 from re import sub as re_sub
 from sys import stdout
 from typing import Any
 from typing import Literal
 from typing import Optional
+from typing import TYPE_CHECKING
 from typing import Union
 
+from pydantic import BaseModel
+
 from .common import JOINABLE
 from ..times import Duration
 from ..times import Times
 from ..types import Empty
+from ..types import clsname
 from ..types.strings import COMMAD
 from ..types.strings import NEWLINE
 from ..types.strings import SEMPTY
 
+if TYPE_CHECKING:
+    from _typeshed import DataclassInstance
+
 
 
 ANSICODE = compile(
@@ -34,7 +43,10 @@ ANSIARRAL = Union[
     tuple[Any, ...],
     set[Any]]
 
-ANSIARRAD = dict[Any, Any]
+ANSIARRAD = Union[
+    dict[Any, Any],
+    BaseModel,
+    'DataclassInstance']
 
 ANSIARRAY = Union[
     ANSIARRAL,
@@ -220,14 +232,21 @@ def array_ansi(  # noqa: CFQ001, CFQ004
             'list': list,
             'tuple': tuple,
             'dict': dict,
+            'BaseModel': BaseModel,
             'frozenset': frozenset,
             'set': set}
 
         items = typing.items()
 
-        for name, _type in items:
+        for name, typed in items:
+
+            if isinstance(value, BaseModel):
+                name = clsname(value)
 
-            if not isinstance(value, _type):
+            elif is_dataclass(value):
+                name = clsname(value)
+
+            elif not isinstance(value, typed):
                 continue
 
             output.append(
@@ -288,6 +307,12 @@ def array_ansi(  # noqa: CFQ001, CFQ004
         refers: Optional[set[int]] = None,
     ) -> None:
 
+        if isinstance(source, BaseModel):
+            source = source.model_dump()
+
+        if is_dataclass(source):
+            source = asdict(source)
+
         assert isinstance(source, dict)
 
         items = source.items()
@@ -325,19 +350,40 @@ def array_ansi(  # noqa: CFQ001, CFQ004
 
 
     def _process(
-        source: ANSIARRAD | ANSIARRAL,
+        source: ANSIARRAY,
         **kwargs: Any,
     ) -> None:
 
         if isinstance(source, dict):
             return _dict(source, **kwargs)
 
-        return _list(source, **kwargs)
+        if isinstance(source, BaseModel):
+            return _dict(source, **kwargs)
+
+        if is_dataclass(source):
+            return _dict(source, **kwargs)
+
+        assert isinstance(
+            source,
+            set | list | tuple)
+
+        _list(source, **kwargs)
+
+
+    if is_dataclass(source):
+
+        assert not isinstance(
+            source, type)
+
+        source = asdict(source)
 
 
     if isinstance(source, dict):
         _dict(source, indent)
 
+    elif isinstance(source, BaseModel):
+        _dict(source, indent)
+
     elif isinstance(source, list):
         _list(source, indent)