encommon 0.10.0__py3-none-any.whl → 0.11.1__py3-none-any.whl

encommon/times/common.py

@@ -7,18 +7,11 @@ 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
 
@@ -68,123 +61,3 @@ STAMP_SUBSEC = (
 
 STAMP_HUMAN = (
     '%m/%d/%Y %I:%M%p %Z')
-
-
-
-def utcdatetime(
-    *args: Any,
-    **kwargs: Any,
-) -> datetime:
-    """
-    Return the instance of datetime within the UTC timezone.
-
-    .. warning::
-       If no arguments are provided, returns current time.
-
-    Example
-    -------
-    >>> utcdatetime(1970, 1, 1)
-    datetime.datetime(1970, 1, 1, 0...
-
-    :param args: Positional arguments passed for downstream.
-    :param kwargs: Keyword arguments passed for downstream.
-    :returns: Instance of datetime within the UTC timezone.
-    """
-
-    tzinfo = timezone.utc
-
-    if not args and not kwargs:
-        return datetime.now(tz=tzinfo)
-
-    if 'tzinfo' not in kwargs:
-        kwargs['tzinfo'] = tzinfo
-
-    return (
-        datetime(*args, **kwargs)
-        .astimezone(timezone.utc))
-
-
-
-def strptime(
-    source: str,
-    formats: str | list[str],
-) -> datetime:
-    """
-    Parse provided time value with various supported formats.
-
-    Example
-    -------
-    >>> strptime('2023', '%Y')
-    datetime.datetime(2023, 1, 1, 0...
-
-    :param source: Time in various forms that will be parsed.
-    :param formats: Various formats compatable with strptime.
-    :returns: Python datetime object containing related time.
-    """
-
-    tzinfo = timezone.utc
-
-    if isinstance(formats, str):
-        formats = [formats]
-
-
-    def _strptime(
-        format: str,
-    ) -> datetime:
-
-        return (
-            datetime
-            .strptime(source, format)
-            .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

encommon/times/params.py

@@ -0,0 +1,155 @@
+"""
+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
+from typing import Optional
+
+from pydantic import BaseModel
+
+from .common import PARSABLE
+from .common import SCHEDULE
+from .times import Times
+
+
+
+class TimerParams(BaseModel, extra='forbid'):
+    """
+    Process and validate the core configuration parameters.
+
+    :param timer: Seconds that are used for related timer.
+    :param start: Optional time for when the timer started.
+    :param data: Keyword arguments passed to Pydantic model.
+        Parameter is picked up by autodoc, please ignore.
+    """
+
+    timer: float
+    start: Optional[str] = None
+
+
+    def __init__(
+        self,
+        timer: int | float,
+        start: Optional[PARSABLE] = None,
+    ) -> None:
+        """
+        Initialize instance for class using provided parameters.
+        """
+
+        if timer is not None:
+            timer = float(timer)
+
+        if start is not None:
+            start = Times(start)
+
+
+        data: dict[str, Any] = {
+            'timer': timer}
+
+        if start is not None:
+            data['start'] = start.subsec
+
+
+        super().__init__(**data)
+
+
+
+class TimersParams(BaseModel, extra='forbid'):
+    """
+    Process and validate the core configuration parameters.
+
+    :param timers: Seconds that are used for related timer.
+    :param data: Keyword arguments passed to Pydantic model.
+        Parameter is picked up by autodoc, please ignore.
+    """
+
+    timers: dict[str, TimerParams] = {}
+
+
+
+class WindowParams(BaseModel, extra='forbid'):
+    """
+    Process and validate the core configuration parameters.
+
+    :param window: Parameters for defining scheduled time.
+    :param start: Determine the start for scheduling window.
+    :param stop: Determine the ending for scheduling window.
+    :param anchor: Optionally define time anchor for window.
+    :param delay: Period of time schedulng will be delayed.
+    :param data: Keyword arguments passed to Pydantic model.
+        Parameter is picked up by autodoc, please ignore.
+    """
+
+    window: SCHEDULE
+
+    start: Optional[str] = None
+    stop: Optional[str] = None
+    anchor: Optional[str] = None
+    delay: float = 0.0
+
+
+    def __init__(
+        self,
+        window: SCHEDULE | int,
+        start: Optional[PARSABLE] = None,
+        stop: Optional[PARSABLE] = None,
+        anchor: Optional[PARSABLE] = None,
+        delay: Optional[int | float] = None,
+    ) -> None:
+        """
+        Initialize instance for class using provided parameters.
+        """
+
+
+        if isinstance(window, int):
+            window = {'seconds': window}
+
+
+        if start is not None:
+            start = Times(start)
+
+        if stop is not None:
+            stop = Times(stop)
+
+        if anchor is not None:
+            anchor = Times(anchor)
+
+        if delay is not None:
+            delay = float(delay)
+
+
+        data: dict[str, Any] = {
+            'window': window}
+
+        if start is not None:
+            data['start'] = start.subsec
+
+        if stop is not None:
+            data['stop'] = stop.subsec
+
+        if anchor is not None:
+            data['anchor'] = anchor.subsec
+
+        if delay is not None:
+            data['delay'] = delay
+
+
+        super().__init__(**data)
+
+
+
+class WindowsParams(BaseModel, extra='forbid'):
+    """
+    Process and validate the core configuration parameters.
+
+    :param windows: Parameters for defining scheduled time.
+    :param data: Keyword arguments passed to Pydantic model.
+        Parameter is picked up by autodoc, please ignore.
+    """
+
+    windows: dict[str, WindowParams] = {}

encommon/times/parse.py

@@ -22,9 +22,9 @@ from .common import NUMERISH
 from .common import PARSABLE
 from .common import SNAPABLE
 from .common import STRINGNOW
-from .common import findtz
-from .common import strptime
-from .common import utcdatetime
+from .utils import findtz
+from .utils import strptime
+from .utils import utcdatetime
 
 if TYPE_CHECKING:
     from .times import Times  # noqa: F401
@@ -201,7 +201,7 @@ def since_time(
     stop: Optional[PARSABLE] = None,
 ) -> float:
     """
-    Determine the time in seconds that occured between values.
+    Determine the time in seconds occurring between values.
 
     Example
     -------
@@ -212,7 +212,7 @@ def since_time(
 
     :param start: Time in various forms that will be parsed.
     :param stop: Time in various forms that will be parsed.
-    :returns: Time in seconds that occured between the values.
+    :returns: Time in seconds occurring between the values.
     """
 
     start = parse_time(start)

encommon/times/test/test_params.py

@@ -0,0 +1,64 @@
+"""
+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 ..params import TimerParams
+from ..params import WindowParams
+
+
+
+def test_TimerParams() -> None:
+    """
+    Perform various tests associated with relevant routines.
+    """
+
+    params = TimerParams(
+        timer=1,
+        start='1980-01-01T00:00:00Z')
+
+    assert params.start == (
+        '1980-01-01T00:00:00.000000+0000')
+
+
+
+def test_WindowParams() -> None:
+    """
+    Perform various tests associated with relevant routines.
+    """
+
+
+    params = WindowParams(
+        window='* * * * *',
+        start='1980-01-01T00:00:00Z',
+        stop='1980-01-02T00:00:00Z',
+        anchor='1980-01-01T00:00:00Z',
+        delay=10)
+
+    assert params.start == (
+        '1980-01-01T00:00:00.000000+0000')
+
+    assert params.stop == (
+        '1980-01-02T00:00:00.000000+0000')
+
+    assert str(params.delay) == '10.0'
+
+
+    params = WindowParams(
+        window=60,
+        start='1980-01-01T00:00:00Z',
+        stop='1980-01-02T00:00:00Z',
+        anchor='1980-01-01T00:00:00Z',
+        delay=10)
+
+    assert params.start == (
+        '1980-01-01T00:00:00.000000+0000')
+
+    assert params.stop == (
+        '1980-01-02T00:00:00.000000+0000')
+
+    assert str(params.delay) == '10.0'

encommon/times/test/test_parse.py

@@ -11,11 +11,11 @@ from datetime import timedelta
 
 from pytest import mark
 
-from ..common import utcdatetime
 from ..parse import parse_time
 from ..parse import shift_time
 from ..parse import since_time
 from ..parse import string_time
+from ..utils import utcdatetime
 
 
 

encommon/times/test/test_timer.py

@@ -0,0 +1,86 @@
+"""
+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 time import sleep
+
+from pytest import fixture
+
+from ..timer import Timer
+from ..times import Times
+from ...types import inrepr
+from ...types import instr
+
+
+
+@fixture
+def timer() -> Timer:
+    """
+    Construct the instance for use in the downstream tests.
+
+    :returns: Newly constructed instance of related class.
+    """
+
+    return Timer(1)
+
+
+
+def test_Timer(
+    timer: Timer,
+) -> None:
+    """
+    Perform various tests associated with relevant routines.
+
+    :param timer: Primary class instance for timer object.
+    """
+
+
+    attrs = list(timer.__dict__)
+
+    assert attrs == [
+        '_Timer__timer',
+        '_Timer__times']
+
+
+    assert inrepr(
+        'timer.Timer object',
+        timer)
+
+    assert hash(timer) > 0
+
+    assert instr(
+        'timer.Timer object',
+        timer)
+
+
+    assert timer.timer == 1
+
+    assert timer.times >= Times('-1s')
+
+    assert timer.since <= 1
+
+    assert timer.remains <= 1
+
+    assert not timer.ready()
+
+
+    sleep(1)
+
+    assert timer.since > 1
+
+    assert timer.remains == 0
+
+    assert timer.ready()
+
+    assert not timer.ready()
+
+    timer.update('1980-01-01')
+
+    assert timer.ready()
+
+    assert not timer.ready()

encommon/times/test/test_timers.py

@@ -9,11 +9,15 @@ is permitted, for more information consult the project license file.
 
 from pathlib import Path
 from time import sleep
+from typing import Any
 
 from pytest import fixture
 from pytest import raises
 
+from ..params import TimerParams
+from ..params import TimersParams
 from ..timers import Timers
+from ..times import Times
 from ...types import inrepr
 from ...types import instr
 
@@ -30,10 +34,45 @@ def timers(
     :returns: Newly constructed instance of related class.
     """
 
-    return Timers(
-        timers={'one': 1},
+    source: dict[str, Any] = {
+        'one': {'timer': 1},
+        'two': {'timer': 1}}
+
+    params = TimersParams(
+        timers=source)
+
+    timers = Timers(
+        params,
         file=f'{tmp_path}/cache.db')
 
+    sqlite = timers.sqlite
+
+    sqlite.execute(
+        """
+        insert into timers
+        ("group", "unique",
+         "update")
+        values (
+         "default", "two",
+         "1970-01-01T00:00:00Z")
+        """)  # noqa: LIT003
+
+    sqlite.execute(
+        """
+        insert into timers
+        ("group", "unique",
+         "update")
+        values (
+         "default", "tre",
+         "1970-01-01T00:00:00Z")
+        """)  # noqa: LIT003
+
+    sqlite.commit()
+
+    timers.load_children()
+
+    return timers
+
 
 
 def test_Timers(
@@ -49,11 +88,12 @@ def test_Timers(
     attrs = list(timers.__dict__)
 
     assert attrs == [
-        '_Timers__config',
+        '_Timers__params',
         '_Timers__sqlite',
         '_Timers__file',
         '_Timers__table',
-        '_Timers__cache']
+        '_Timers__group',
+        '_Timers__timers']
 
 
     assert inrepr(
@@ -67,7 +107,7 @@ def test_Timers(
         timers)
 
 
-    assert timers.timers == {'one': 1}
+    assert timers.params is not None
 
     assert timers.sqlite is not None
 
@@ -75,36 +115,23 @@ def test_Timers(
 
     assert timers.table == 'timers'
 
-    assert list(timers.cache) == ['one']
-
-
-
-def test_Timers_cover(
-    timers: Timers,
-) -> None:
-    """
-    Perform various tests associated with relevant routines.
-
-    :param timers: Primary class instance for timers object.
-    """
-
+    assert timers.group == 'default'
 
-    assert not timers.ready('one')
+    assert len(timers.children) == 2
 
-    sleep(1.1)
 
-    assert timers.ready('one')
+    timer = timers.children['one']
 
+    assert timer.times >= Times('-1s')
 
-    timers.create('two', 2, 0)
 
-    assert timers.ready('two')
+    timer = timers.children['two']
 
-    assert not timers.ready('two')
+    assert timer.times == '1970-01-01'
 
 
 
-def test_Timers_cache(
+def test_Timers_cover(
     timers: Timers,
 ) -> None:
     """
@@ -113,27 +140,28 @@ def test_Timers_cache(
     :param timers: Primary class instance for timers object.
     """
 
-    timers1 = Timers(
-        timers={'uno': 1},
-        file=timers.file)
 
-    assert not timers1.ready('uno')
+    assert timers.ready('two')
+
+    timers.update('two', 'now')
+
+    assert not timers.ready('two')
+
+
+    timers = Timers()
+
 
-    sleep(0.75)
+    params = TimerParams(timer=1)
 
-    timers2 = Timers(
-        timers={'uno': 1},
-        file=timers.file)
+    timers.create('fur', params)
 
-    assert not timers1.ready('uno')
-    assert not timers2.ready('uno')
+    assert not timers.ready('fur')
 
-    sleep(0.25)
+    sleep(1)
 
-    timers2.load_cache()
+    assert timers.ready('fur')
 
-    assert timers1.ready('uno')
-    assert timers2.ready('uno')
+    timers.delete('fur')
 
 
 
@@ -157,10 +185,22 @@ def test_Timers_raises(
     assert _reason == 'unique'
 
 
+    _raises = raises(ValueError)
+
+    params = TimerParams(timer=1)
+
+    with _raises as reason:
+        timers.create('one', params)
+
+    _reason = str(reason.value)
+
+    assert _reason == 'unique'
+
+
     _raises = raises(ValueError)
 
     with _raises as reason:
-        timers.update('dne')
+        timers.update('dne', 'now')
 
     _reason = str(reason.value)
 
@@ -170,7 +210,7 @@ def test_Timers_raises(
     _raises = raises(ValueError)
 
     with _raises as reason:
-        timers.create('one', 1)
+        timers.delete('dne')
 
     _reason = str(reason.value)
 

encommon/times/test/{test_common.py → test_utils.py}

@@ -13,9 +13,9 @@ from pytest import raises
 
 from ..common import STAMP_SIMPLE
 from ..common import UNIXEPOCH
-from ..common import findtz
-from ..common import strptime
-from ..common import utcdatetime
+from ..utils import findtz
+from ..utils import strptime
+from ..utils import utcdatetime