encommon 0.7.6__py3-none-any.whl → 0.8.0__py3-none-any.whl

encommon/config/test/test_paths.py

@@ -9,12 +9,32 @@ is permitted, for more information consult the project license file.
 
 from pathlib import Path
 
+from pytest import fixture
+
 from . import SAMPLES
 from ..paths import ConfigPath
 from ..paths import ConfigPaths
 from ... import ENPYRWS
-from ...utils.sample import load_sample
-from ...utils.sample import prep_sample
+from ... import PROJECT
+from ...utils import load_sample
+from ...utils import prep_sample
+
+
+
+@fixture
+def paths(
+    config_path: Path,
+) -> ConfigPaths:
+    """
+    Construct the instance for use in the downstream tests.
+
+    :param config_path: Custom fixture for populating paths.
+    :returns: Newly constructed instance of related class.
+    """
+
+    return ConfigPaths([
+        f'{SAMPLES}/stark',
+        f'{SAMPLES}/wayne'])
 
 
 
@@ -29,33 +49,38 @@ def test_ConfigPath(
 
     path = ConfigPath(config_path)
 
+
     attrs = list(path.__dict__)
 
-    assert attrs == ['path', 'config']
+    assert attrs == [
+        'path',
+        'config']
+
+
+    assert repr(path)[:22] == (
+        '<encommon.config.paths')
+
+    assert hash(path) > 0
 
+    assert str(path)[:22] == (
+        '<encommon.config.paths')
 
-    assert repr(path).startswith(
-        '<encommon.config.paths.ConfigPath')
-    assert isinstance(hash(path), int)
-    assert str(path).startswith(
-        '<encommon.config.paths.ConfigPath')
 
+    assert 'test' in path.path.name
 
-    assert path.path == config_path
-    assert len(path.config) == 2
+    assert len(path.config) == 1
 
 
 
 def test_ConfigPaths(
-    config_path: Path,
+    paths: ConfigPaths,
 ) -> None:
     """
     Perform various tests associated with relevant routines.
 
-    :param config_path: Custom fixture for populating paths.
+    :param paths: Custom fixture for the configuration paths.
     """
 
-    paths = ConfigPaths(config_path)
 
     attrs = list(paths.__dict__)
 
@@ -64,35 +89,50 @@ def test_ConfigPaths(
         '_ConfigPaths__merged']
 
 
-    assert repr(paths).startswith(
-        '<encommon.config.paths.ConfigPaths')
-    assert isinstance(hash(paths), int)
-    assert str(paths).startswith(
-        '<encommon.config.paths.ConfigPaths')
+    assert repr(paths)[:22] == (
+        '<encommon.config.paths')
+
+    assert hash(paths) > 0
+
+    assert str(paths)[:22] == (
+        '<encommon.config.paths')
 
 
-    assert len(paths.paths) == 1
-    assert len(paths.config) == 1
+    assert len(paths.paths) == 2
 
+    assert len(paths.config) == 2
 
-    _merged1 = paths.merged
-    _merged2 = paths.merged
 
-    assert _merged1 is not _merged2
+    replaces = {
+        'PROJECT': PROJECT}
 
-    sample_path = Path(
+    sample_path = (
         f'{SAMPLES}/paths.json')
 
     sample = load_sample(
         path=sample_path,
         update=ENPYRWS,
-        content=_merged1,
-        replace={
-            'config_path': str(config_path)})
+        content=paths.merged,
+        replace=replaces)
 
     expect = prep_sample(
-        content=_merged2,
-        replace={
-            'config_path': str(config_path)})
+        content=paths.merged,
+        replace=replaces)
 
     assert sample == expect
+
+
+
+def test_ConfigPaths_cover(
+    paths: ConfigPaths,
+) -> None:
+    """
+    Perform various tests associated with relevant routines.
+
+    :param paths: Custom fixture for the configuration paths.
+    """
+
+    merged1 = paths.merged
+    merged2 = paths.merged
+
+    assert merged1 is not merged2

encommon/conftest.py

@@ -11,6 +11,46 @@ from pathlib import Path
 
 from pytest import fixture
 
+from .config import Config
+from .config.test import SAMPLES
+from .utils import save_text
+
+
+
+def config_factory(
+    tmp_path: Path,
+) -> Config:
+    """
+    Construct the instance for use in the downstream tests.
+
+    :param tmp_path: pytest object for temporal filesystem.
+    :returns: Newly constructed instance of related class.
+    """
+
+    save_text(
+        f'{tmp_path}/config.yml',
+        content=(
+            'enconfig:\n'
+            '  paths:\n'
+            f"    - '{SAMPLES}/stark'\n"
+            f"    - '{SAMPLES}/wayne'\n"
+            'enlogger:\n'
+            '  stdo_level: info\n'
+            'encrypts:\n'
+            '  phrases:\n'
+            '    default: phrase\n'))
+
+    config_log = f'{tmp_path}/config.log'
+
+    cargs = {
+        'enlogger': {
+            'file_path': config_log,
+            'file_level': 'info'}}
+
+    return Config(
+        files=f'{tmp_path}/config.yml',
+        cargs=cargs)
+
 
 
 @fixture
@@ -24,21 +64,21 @@ def config_path(
     :returns: New resolved filesystem path object instance.
     """
 
+    config_factory(tmp_path)
 
-    Path.mkdir(
-        Path(f'{tmp_path}/wayne'))
-
-    (Path(f'{tmp_path}/wayne')
-        .joinpath('bwayne.yml')
-        .write_text('name: Bruce Wayne'))
+    return tmp_path.resolve()
 
 
-    Path.mkdir(
-        Path(f'{tmp_path}/stark'))
 
-    (Path(f'{tmp_path}/stark')
-        .joinpath('tstark.yml')
-        .write_text('name: Tony Stark'))
+@fixture
+def config(
+    tmp_path: Path,
+) -> Config:
+    """
+    Construct the instance for use in the downstream tests.
 
+    :param tmp_path: pytest object for temporal filesystem.
+    :returns: Newly constructed instance of related class.
+    """
 
-    return tmp_path.resolve()
+    return config_factory(tmp_path)

encommon/crypts/__init__.py

@@ -9,9 +9,11 @@ is permitted, for more information consult the project license file.
 
 from .crypts import Crypts
 from .hashes import Hashes
+from .params import CryptsParams
 
 
 
 __all__ = [
     'Crypts',
+    'CryptsParams',
     'Hashes']

encommon/crypts/crypts.py

@@ -15,6 +15,8 @@ from typing import TYPE_CHECKING
 
 from cryptography.fernet import Fernet
 
+from ..types.strings import SEMPTY
+
 if TYPE_CHECKING:
     from .params import CryptsParams
 
@@ -157,4 +159,4 @@ def crypt_clean(
     :param value: String value that will returned decrypted.
     """
 
-    return re_sub(r'[\n\s]', '', value)
+    return re_sub(r'[\n\s]', SEMPTY, value)

encommon/crypts/hashes.py

@@ -90,7 +90,7 @@ class Hashes:
 
         string = self.__string.encode()
 
-        return sha1(string).hexdigest()  # noqa: S324
+        return sha1(string).hexdigest()
 
 
     @property
@@ -151,6 +151,6 @@ class Hashes:
 
         string = self.__string.encode()
 
-        digest = sha1(string).digest()  # noqa: S324
+        digest = sha1(string).digest()
 
         return b64encode(digest).decode()

encommon/crypts/test/test_crypts.py

@@ -12,33 +12,38 @@ from pytest import mark
 from pytest import raises
 
 from ..crypts import Crypts
+from ..params import CryptsParams
 
 
 
 @fixture
-def phrases() -> dict[str, str]:
+def crypts() -> Crypts:
     """
-    Construct randomly generated Fernet keys for passphrases.
+    Construct the instance for use in the downstream tests.
 
-    :returns: Randomly generated Fernet keys for passphrases.
+    :returns: Newly constructed instance of related class.
     """
 
-    return {
+    phrases = {
         'default': Crypts.keygen(),
         'secrets': Crypts.keygen()}
 
+    params = CryptsParams(
+        phrases=phrases)
+
+    return Crypts(params=params)
+
 
 
 def test_Crypts(
-    phrases: dict[str, str],
+    crypts: Crypts,
 ) -> None:
     """
     Perform various tests associated with relevant routines.
 
-    :param phrases: Dictionary of randomly generated phrases.
+    :param crypts: Primary class instance for the encryption.
     """
 
-    crypts = Crypts(phrases)
 
     attrs = list(crypts.__dict__)
 
@@ -46,14 +51,18 @@ def test_Crypts(
         '_Crypts__phrases']
 
 
-    assert repr(crypts).startswith(
-        '<encommon.crypts.crypts.Crypts')
-    assert isinstance(hash(crypts), int)
-    assert str(crypts).startswith(
-        '<encommon.crypts.crypts.Crypts')
+    assert repr(crypts)[:23] == (
+        '<encommon.crypts.crypts')
+
+    assert hash(crypts) > 0
 
+    assert str(crypts)[:23] == (
+        '<encommon.crypts.crypts')
 
-    assert crypts.phrases == phrases
+
+    assert len(crypts.phrases) == 2
+
+    assert len(crypts.keygen()) == 44
 
 
 
@@ -62,21 +71,20 @@ def test_Crypts(
     [('foo', 'default'),
      ('foo', 'secrets')])
 def test_Crypts_iterate(
+    crypts: Crypts,
     value: str,
     unique: str,
-    phrases: dict[str, str],
 ) -> None:
     """
     Perform various tests associated with relevant routines.
 
+    :param crypts: Primary class instance for the encryption.
     :param value: String value that will returned encrypted.
     :param unique: Unique identifier of mapping passphrase.
-    :param phrases: Dictionary of randomly generated phrases.
     """
 
-    crypts = Crypts(phrases)
-
-    encrypt = crypts.encrypt(value, unique)
+    encrypt = (
+        crypts.encrypt(value, unique))
 
     split = encrypt.split(';')
 
@@ -90,31 +98,45 @@ def test_Crypts_iterate(
 
 
 def test_Crypts_raises(
-    phrases: dict[str, str],
+    crypts: Crypts,
 ) -> None:
     """
     Perform various tests associated with relevant routines.
 
-    :param phrases: Dictionary of randomly generated phrases.
+    :param crypts: Primary class instance for the encryption.
     """
 
 
-    with raises(ValueError) as reason:
+    _raises = raises(ValueError)
+
+    with _raises as reason:
         Crypts({'foo': 'bar'})
 
-    assert str(reason.value) == 'default'
+    _reason = str(reason.value)
+
+    assert _reason == 'default'
+
 
+    crypts = Crypts(
+        crypts.phrases)
 
-    crypts = Crypts(phrases)
 
+    _raises = raises(ValueError)
 
-    with raises(ValueError) as reason:
+    with _raises as reason:
         crypts.decrypt('foo')
 
-    assert str(reason.value) == 'string'
+    _reason = str(reason.value)
+
+    assert _reason == 'string'
+
+
+    _raises = raises(ValueError)
 
+    with _raises as reason:
+        string = '$ENCRYPT;1.1;f;oo'
+        crypts.decrypt(string)
 
-    with raises(ValueError) as reason:
-        crypts.decrypt('$ENCRYPT;1.1;f;oo')
+    _reason = str(reason.value)
 
-    assert str(reason.value) == 'version'
+    assert _reason == 'version'

encommon/crypts/test/test_hashes.py

@@ -18,36 +18,38 @@ def test_Hashes() -> None:
 
     hashes = Hashes('string')
 
+
     attrs = list(hashes.__dict__)
 
     assert attrs == [
         '_Hashes__string']
 
 
-    assert repr(hashes).startswith(
-        '<encommon.crypts.hashes.Hashes')
-    assert isinstance(hash(hashes), int)
-    assert str(hashes).startswith(
-        '<encommon.crypts.hashes.Hashes')
+    assert repr(hashes)[:23] == (
+        '<encommon.crypts.hashes')
 
+    assert hash(hashes) > 0
 
-    assert hashes.string == 'string'
+    assert str(hashes)[:23] == (
+        '<encommon.crypts.hashes')
 
 
-    assert hashes.md5.startswith('b4')
-    assert hashes.md5.endswith('0f21')
+    assert hashes.string == 'string'
+
+    assert hashes.md5[:3] == 'b45'
+    assert hashes.md5[-2:] == '21'
 
-    assert hashes.sha1.startswith('ec')
-    assert hashes.sha1.endswith('904d')
+    assert hashes.sha1[:3] == 'ecb'
+    assert hashes.sha1[-2:] == '4d'
 
-    assert hashes.sha256.startswith('47')
-    assert hashes.sha256.endswith('2fa8')
+    assert hashes.sha256[:3] == '473'
+    assert hashes.sha256[-2:] == 'a8'
 
-    assert hashes.sha512.startswith('27')
-    assert hashes.sha512.endswith('6a87')
+    assert hashes.sha512[:3] == '275'
+    assert hashes.sha512[-2:] == '87'
 
-    assert hashes.uuid.startswith('38')
-    assert hashes.uuid.endswith('eee4')
+    assert hashes.uuid[:3] == '38f'
+    assert hashes.uuid[-2:] == 'e4'
 
-    assert hashes.apache.startswith('7L')
-    assert hashes.apache.endswith('kE0=')
+    assert hashes.apache[:3] == '7LJ'
+    assert hashes.apache[-2:] == '0='

encommon/times/__init__.py

@@ -7,6 +7,7 @@ is permitted, for more information consult the project license file.
 
 
 
+from .common import findtz
 from .duration import Duration
 from .parse import parse_time
 from .parse import shift_time
@@ -20,6 +21,7 @@ from .window import Window
 
 __all__ = [
     'Duration',
+    'findtz',
     'Timers',
     'Times',
     'Window',

encommon/times/common.py

@@ -10,30 +10,64 @@ is permitted, for more information consult the project license file.
 from contextlib import suppress
 from datetime import datetime
 from datetime import timezone
+from datetime import tzinfo
 from re import compile
 from typing import Any
+from typing import Optional
 from typing import TYPE_CHECKING
 from typing import Union
+
+from dateutil.tz import gettz
+
 if TYPE_CHECKING:
     from .times import Times
 
 
 
-NUMERISH = compile(r'^\-?\d+(\.\d+)?$')
-SNAPABLE = compile(r'^(\-|\+)[\d\@a-z\-\+]+$')
-STRINGNOW = {'None', 'null', 'now'}
+NUMERISH = compile(
+    r'^\-?\d+(\.\d+)?$')
+
+SNAPABLE = compile(
+    r'^(\-|\+)[\d\@a-z\-\+]+$')
+
+STRINGNOW = {
+    'None', 'null', 'now'}
+
+
 
 NUMERIC = Union[int, float]
-PARSABLE = Union[str, NUMERIC, datetime, 'Times']
-SCHEDULE = Union[str, dict[str, int]]
 
-UNIXEPOCH = '1970-01-01T00:00:00+0000'
-UNIXMPOCH = '1970-01-01T00:00:00.000000+0000'
-UNIXHPOCH = '01/01/1970 12:00AM UTC'
+PARSABLE = Union[
+    str, NUMERIC,
+    datetime, 'Times']
+
+SCHEDULE = Union[
+    str, dict[str, int]]
+
+
+
+UNIXEPOCH = (
+    '1970-01-01T00:00:00+0000')
+
+UNIXMPOCH = (
+    '1970-01-01T00:00:00.000000+0000')
 
-STAMP_SIMPLE = '%Y-%m-%dT%H:%M:%S%z'
-STAMP_SUBSEC = '%Y-%m-%dT%H:%M:%S.%f%z'
-STAMP_HUMAN = '%m/%d/%Y %I:%M%p %Z'
+UNIXSPOCH = (
+    '1970-01-01T00:00:00Z')
+
+UNIXHPOCH = (
+    '01/01/1970 12:00AM UTC')
+
+
+
+STAMP_SIMPLE = (
+    '%Y-%m-%dT%H:%M:%S%z')
+
+STAMP_SUBSEC = (
+    '%Y-%m-%dT%H:%M:%S.%f%z')
+
+STAMP_HUMAN = (
+    '%m/%d/%Y %I:%M%p %Z')
 
 
 
@@ -57,14 +91,16 @@ def utcdatetime(
     :returns: Instance of datetime within the UTC timezone.
     """
 
+    tzinfo = timezone.utc
+
     if not args and not kwargs:
-        return datetime.now(tz=timezone.utc)
+        return datetime.now(tz=tzinfo)
 
     if 'tzinfo' not in kwargs:
-        kwargs['tzinfo'] = timezone.utc
+        kwargs['tzinfo'] = tzinfo
 
     return (
-        datetime(*args, **kwargs)  # noqa: DTZ001
+        datetime(*args, **kwargs)
         .astimezone(timezone.utc))
 
 
@@ -86,6 +122,8 @@ def strptime(
     :returns: Python datetime object containing related time.
     """
 
+    tzinfo = timezone.utc
+
     if isinstance(formats, str):
         formats = [formats]
 
@@ -93,14 +131,60 @@ def strptime(
     def _strptime(
         format: str,
     ) -> datetime:
+
         return (
             datetime
             .strptime(source, format)
-            .astimezone(timezone.utc))
+            .astimezone(tzinfo))
 
 
     for format in formats:
+
         with suppress(ValueError):
             return _strptime(format)
 
+
     raise ValueError('invalid')
+
+
+
+def strftime(
+    source: datetime,
+    format: str,
+) -> str:
+    """
+    Return the timestamp string for datetime object provided.
+
+    .. note::
+       This function is extremely pedantic and cosmetic.
+
+    :param source: Python datetime instance containing source.
+    :param format: Format for the timestamp string returned.
+    :returns: Timestamp string for datetime object provided.
+    """
+
+    return (
+        datetime
+        .strftime(source, format))
+
+
+
+def findtz(
+    tzname: Optional[str] = None,
+) -> tzinfo:
+    """
+    Return the located timezone object for the provided name.
+
+    :param tzname: Name of the timezone associated to source.
+    :returns: Located timezone object for the provided name.
+    """
+
+    if tzname is None:
+        return timezone.utc
+
+    tzinfo = gettz(tzname)
+
+    if tzinfo is None:
+        raise ValueError('tzname')
+
+    return tzinfo