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

encommon/utils/sample.py

@@ -7,54 +7,80 @@ 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 DictStrAny
+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[DictStrAny] = 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
+    ) -> DictStrAny | 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 +88,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 +105,9 @@ def load_sample(
     update: bool = False,
     *,
     default: Callable[[Any], str] = str,
-    replace: Optional['REPLACE'] = None,
-) -> Any:
-    """
+    replace: Optional[DictStrAny] = None,
+) -> str:
+    r"""
     Load the sample file and compare using provided content.
 
     .. testsetup::
@@ -96,14 +120,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 +135,7 @@ def load_sample(
     :returns: Content after processing using JSON functions.
     """
 
+
     path = Path(path).resolve()
 
     loaded: Optional[Any] = None
@@ -123,18 +148,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 +168,62 @@ def load_sample(
 
 
     return _load_sample()
+
+
+
+def read_sample(
+    sample: str,
+    *,
+    replace: Optional[DictStrAny] = 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[DictStrAny] = 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 ..times import Time
 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(
@@ -268,7 +287,7 @@ def array_ansi(  # noqa: CFQ001, CFQ004
         elif isinstance(source, Duration):
             color = colors.times
 
-        elif isinstance(source, Times):
+        elif isinstance(source, Time):
             color = colors.times
 
         elif source is Empty:
@@ -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)
 

encommon/utils/test/test_paths.py

@@ -13,7 +13,7 @@ from ..paths import resolve_path
 from ..paths import resolve_paths
 from ..paths import stats_path
 from ... import PROJECT
-from ...times import Times
+from ...times import Time
 
 
 
@@ -67,9 +67,9 @@ def test_stats_path() -> None:
     stat = stats['/utils/paths.py']
 
     assert stat.st_ctime >= (
-        Times('2023-01-01').epoch)
+        Time('2023-01-01').epoch)
     assert stat.st_mtime >= (
-        Times('2023-01-01').epoch)
+        Time('2023-01-01').epoch)
 
     assert stat.st_size >= 2000
 

encommon/utils/test/test_sample.py

@@ -7,12 +7,41 @@ is permitted, for more information consult the project license file.
 
 
 
+from copy import deepcopy
+from json import dumps
+from json import loads
 from pathlib import Path
 
 from ..sample import load_sample
 from ..sample import prep_sample
-from ... import ENPYRWS
+from ..sample import read_sample
+from ..sample import rvrt_sample
+from ..stdout import ArrayColors
 from ... import PROJECT
+from ...config import LoggerParams
+from ...utils.sample import ENPYRWS
+
+
+
+_PREFIX = 'encommon_sample'
+
+_SOURCE = {
+    'list': ['bar', 'baz'],
+    'tuple': (1, 2),
+    'project': PROJECT,
+    'other': '/pat/h',
+    'devnull': '/dev/null'}
+
+_EXPECT = {
+    'list': ['bar', 'baz'],
+    'tuple': [1, 2],
+    'project': f'_/{_PREFIX}/PROJECT/_',
+    'other': f'_/{_PREFIX}/pytemp/_',
+    'devnull': '/dev/null'}
+
+_REPLACES = {
+    'PROJECT': str(PROJECT),
+    'pytemp': '/pat/h'}
 
 
 
@@ -21,7 +50,35 @@ def test_prep_sample() -> None:
     Perform various tests associated with relevant routines.
     """
 
-    assert prep_sample((1, '2')) == [1, '2']
+    colors = ArrayColors()
+
+    params = LoggerParams()
+
+    source = {
+        'colors': colors,
+        'params': params}
+
+    sample = prep_sample(
+        content=source,
+        indent=None)
+
+    assert loads(sample) == {
+        'colors': {
+            'bool': 93,
+            'colon': 37,
+            'empty': 36,
+            'hyphen': 37,
+            'key': 97,
+            'label': 37,
+            'none': 33,
+            'num': 93,
+            'other': 91,
+            'str': 92,
+            'times': 96},
+        'params': {
+            'file_level': None,
+            'file_path': None,
+            'stdo_level': None}}
 
 
 
@@ -34,41 +91,24 @@ def test_load_sample(
     :param tmp_path: pytest object for temporal filesystem.
     """
 
-    prefix = 'encommon_sample'
-
-    source = {
-        'list': ['bar', 'baz'],
-        'tuple': (1, 2),
-        'project': PROJECT,
-        'other': '/pat/h',
-        'devnull': '/dev/null'}
-
-    expect = {
-        'list': ['bar', 'baz'],
-        'tuple': [1, 2],
-        'project': f'_/{prefix}/PROJECT/_',
-        'other': f'_/{prefix}/pytemp/_',
-        'devnull': '/dev/null'}
-
+    source = deepcopy(_SOURCE)
 
-    devnull = Path('/dev/null')
-
-    replaces = {
-        devnull: 'nothing here',
-        'PROJECT': str(PROJECT),
-        'pytemp': '/pat/h'}
+    expect = deepcopy(_EXPECT)
 
 
     sample_path = (
-        f'{tmp_path}/samples.json')
+        tmp_path / 'samples.json')
 
     sample = load_sample(
         path=sample_path,
         update=ENPYRWS,
         content=source,
-        replace=replaces)  # type: ignore
+        replace=_REPLACES)
+
+    _expect = dumps(
+        expect, indent=2)
 
-    assert sample == expect
+    assert _expect == sample
 
 
     source |= {'list': [1, 3, 2]}
@@ -78,6 +118,65 @@ def test_load_sample(
         path=sample_path,
         content=source,
         update=True,
-        replace=replaces)  # type: ignore
+        replace=_REPLACES)
+
+    _expect = dumps(
+        expect, indent=2)
+
+    assert _expect == sample
+
+
+
+def test_read_sample(
+    tmp_path: Path,
+) -> None:
+    """
+    Perform various tests associated with relevant routines.
+
+    :param tmp_path: pytest object for temporal filesystem.
+    """
+
+    source = prep_sample(
+        content=_SOURCE,
+        indent=None)
+
+    sample = read_sample(
+        sample=source,
+        replace=_REPLACES)
+
+    sample = prep_sample(
+        content=loads(sample),
+        replace=_REPLACES,
+        indent=None)
+
+    expect = dumps(_EXPECT)
+
+    assert expect == sample
+
+
+
+def test_rvrt_sample(
+    tmp_path: Path,
+) -> None:
+    """
+    Perform various tests associated with relevant routines.
+
+    :param tmp_path: pytest object for temporal filesystem.
+    """
+
+    source = prep_sample(
+        content=_SOURCE,
+        indent=None)
+
+    sample = rvrt_sample(
+        sample=source,
+        replace=_REPLACES)
+
+    sample = prep_sample(
+        content=loads(sample),
+        replace=_REPLACES,
+        indent=None)
+
+    expect = dumps(_EXPECT)
 
-    assert sample == expect
+    assert expect == sample