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

encommon/times/test/test_window.py

@@ -7,11 +7,13 @@ is permitted, for more information consult the project license file.
 
 
 
+from time import sleep
 from typing import TYPE_CHECKING
 
 from pytest import fixture
 from pytest import mark
 
+from ..times import Times
 from ..window import Window
 from ..window import window_croniter
 from ..window import window_interval
@@ -32,8 +34,10 @@ def window() -> Window:
     """
 
     return Window(
-        schedule='* * * * *',
-        start=330, stop=630)
+        window='* * * * *',
+        start=300,
+        stop=600,
+        delay=10)
 
 
 
@@ -50,14 +54,13 @@ def test_Window(
     attrs = list(window.__dict__)
 
     assert attrs == [
-        '_Window__schedule',
+        '_Window__window',
         '_Window__start',
         '_Window__stop',
         '_Window__anchor',
         '_Window__delay',
-        '_Window__wilast',
-        '_Window__winext',
-        '_Window__walked']
+        '_Window__wlast',
+        '_Window__wnext']
 
 
     assert inrepr(
@@ -71,21 +74,28 @@ def test_Window(
         window)
 
 
-    assert window.schedule == '* * * * *'
+    assert window.window == '* * * * *'
 
-    assert window.start == '1970-01-01T00:05:30Z'
+    assert window.start == (
+        '1970-01-01T00:05:00Z')
 
-    assert window.stop == '1970-01-01T00:10:30Z'
+    assert window.stop == (
+        '1970-01-01T00:10:00Z')
 
     assert window.anchor == window.start
 
-    assert window.delay == 0.0
+    assert str(window.delay) == '10.0'
 
-    assert window.last == '1970-01-01T00:05:00Z'
+    assert window.last == (
+        '1970-01-01T00:04:00Z')
 
-    assert window.next == '1970-01-01T00:06:00Z'
+    assert window.next == (
+        '1970-01-01T00:05:00Z')
 
-    assert window.walked is False
+    assert window.latest == (
+        '1970-01-01T00:09:50Z')
+
+    assert not window.walked
 
 
 
@@ -100,59 +110,99 @@ def test_Window_cover(
 
 
     window = Window(
-        schedule='* * * * *',
+        window={'minutes': 1},
         start=window.start,
         stop=window.stop)
 
-    assert window.last == '1970-01-01T00:05:00Z'
-    assert window.next == '1970-01-01T00:06:00Z'
-    assert window.walked is False
+    assert window.last == (
+        '1970-01-01T00:04:00Z')
+
+    assert window.next == (
+        '1970-01-01T00:05:00Z')
+
+    assert not window.walked
 
     for count in range(100):
-        if window.walk() is False:
+        if window.walked:
             break
-        assert window.walk(False)
+        assert window.ready()
+
+    assert count == 5
+    assert not window.ready()
+
+    assert window.last == (
+        '1970-01-01T00:09:00Z')
 
-    assert count == 4
-    assert not window.walk()
+    assert window.next == (
+        '1970-01-01T00:10:00Z')
 
-    assert window.last == '1970-01-01T00:10:00Z'
-    assert window.next == '1970-01-01T00:10:00Z'
-    assert window.walked is True
+    assert window.walked
 
 
     window = Window(
-        schedule={'minutes': 1},
+        window='* * * * *',
         start=window.start,
         stop=window.stop)
 
-    assert window.last == '1970-01-01T00:04:30Z'
-    assert window.next == '1970-01-01T00:05:30Z'
-    assert window.walked is False
+    assert window.last == (
+        '1970-01-01T00:04:00Z')
+
+    assert window.next == (
+        '1970-01-01T00:05:00Z')
+
+    assert not window.walked
 
     for count in range(100):
-        if window.walk() is False:
+        if window.walked:
             break
-        assert window.walk(False)
+        assert window.ready()
 
     assert count == 5
-    assert not window.walk()
+    assert not window.ready()
+
+    assert window.last == (
+        '1970-01-01T00:09:00Z')
+
+    assert window.next == (
+        '1970-01-01T00:10:00Z')
+
+    assert window.walked
 
-    assert window.last == '1970-01-01T00:10:30Z'
-    assert window.next == '1970-01-01T00:10:30Z'
-    assert window.walked is True
+
+    anchor = Times('-0s@s')
+
+
+    window = Window(
+        window='* * * * *',
+        start=anchor.shift('+5m'),
+        stop=anchor.shift('+10m'))
+
+    assert not window.ready(False)
 
 
     window = Window(
-        schedule='* * * * *',
-        start='+5m', stop='+10m')
+        window={'seconds': 1},
+        start=anchor.shift('-5s'),
+        stop=anchor.shift('+5s'))
+
+    assert not window.walked
+
+    for count in range(100):
+        if window.walked:
+            break
+        if window.ready():
+            continue
+        sleep(0.25)
+
+    assert 16 <= count <= 32
+    assert not window.ready()
 
-    assert not window.walk(False)
+    assert window.walked
 
 
 
 @mark.parametrize(
-    'schedule,anchor,backward,expect',
+    'window,anchor,backward,expect',
     [('* * * * *', 0, False, (0, 60)),
      ('* * * * *', 1, False, (0, 60)),
      ('* * * * *', 0, True, (-60, 0)),
@@ -165,7 +215,7 @@ def test_Window_cover(
      ('0 * * * *', 3660, False, (3600, 7200)),
      ('0 * * * *', 3661, False, (3600, 7200))])
 def test_window_croniter(
-    schedule: str,
+    window: str,
     anchor: 'PARSABLE',
     backward: bool,
     expect: tuple[int, int],
@@ -173,22 +223,22 @@ def test_window_croniter(
     """
     Perform various tests associated with relevant routines.
 
-    :param schedule: Parameters for defining scheduled time.
+    :param window: Parameters for defining scheduled time.
     :param anchor: Optionally define time anchor for window.
     :param backward: Optionally operate the window backward.
     :param expect: Expected output from the testing routine.
     """
 
-    window = window_croniter(
-        schedule, anchor, backward)
+    croniter = window_croniter(
+        window, anchor, backward)
 
-    assert window[0] == expect[0]
-    assert window[1] == expect[1]
+    assert croniter[0] == expect[0]
+    assert croniter[1] == expect[1]
 
 
 
 @mark.parametrize(
-    'schedule,anchor,backward,expect',
+    'window,anchor,backward,expect',
     [({'seconds': 60}, 0, False, (0, 60)),
      ({'seconds': 60}, 1, False, (1, 61)),
      ({'seconds': 60}, 0, True, (-60, 0)),
@@ -201,7 +251,7 @@ def test_window_croniter(
      ({'hours': 1}, 3660, False, (3660, 7260)),
      ({'hours': 1}, 3661, False, (3661, 7261))])
 def test_window_interval(
-    schedule: dict[str, int],
+    window: dict[str, int],
     anchor: 'PARSABLE',
     backward: bool,
     expect: tuple[int, int],
@@ -209,14 +259,14 @@ def test_window_interval(
     """
     Perform various tests associated with relevant routines.
 
-    :param schedule: Parameters for defining scheduled time.
+    :param window: Parameters for defining scheduled time.
     :param anchor: Optionally define time anchor for window.
     :param backward: Optionally operate the window backward.
     :param expect: Expected output from the testing routine.
     """
 
-    window = window_interval(
-        schedule, anchor, backward)
+    interval = window_interval(
+        window, anchor, backward)
 
-    assert window[0] == expect[0]
-    assert window[1] == expect[1]
+    assert interval[0] == expect[0]
+    assert interval[1] == expect[1]

encommon/times/test/test_windows.py

@@ -0,0 +1,264 @@
+"""
+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 pathlib import Path
+from typing import Any
+
+from pytest import fixture
+from pytest import raises
+
+from ..params import WindowParams
+from ..params import WindowsParams
+from ..windows import Windows
+from ...types import inrepr
+from ...types import instr
+
+
+
+@fixture
+def windows(
+    tmp_path: Path,
+) -> Windows:
+    """
+    Construct the instance for use in the downstream tests.
+
+    :param tmp_path: pytest object for temporal filesystem.
+    :returns: Newly constructed instance of related class.
+    """
+
+    source: dict[str, Any] = {
+        'one': WindowParams(
+            window='* * * * *',
+            start=310,
+            stop=610,
+            delay=10),
+        'two': WindowParams(
+            window='* * * * *',
+            start=300,
+            stop=620,
+            delay=10)}
+
+    params = WindowsParams(
+        windows=source)
+
+    windows = Windows(
+        params,
+        start=310,
+        stop=610,
+        file=f'{tmp_path}/cache.db')
+
+    sqlite = windows.sqlite
+
+    sqlite.execute(
+        """
+        insert into windows
+        ("group", "unique",
+         "last", "next",
+         "update")
+        values (
+         "default", "two",
+         "1970-01-01T00:06:00Z",
+         "1970-01-01T00:07:00Z",
+         "1970-01-01T01:00:00Z")
+        """)  # noqa: LIT003
+
+    sqlite.commit()
+
+    sqlite.execute(
+        """
+        insert into windows
+        ("group", "unique",
+         "last", "next",
+         "update")
+        values (
+         "default", "tre",
+         "1970-01-01T00:06:00Z",
+         "1970-01-01T00:07:00Z",
+         "1970-01-01T01:00:00Z")
+        """)  # noqa: LIT003
+
+    sqlite.commit()
+
+    windows.load_children()
+
+    return windows
+
+
+
+def test_Windows(
+    windows: 'Windows',
+) -> None:
+    """
+    Perform various tests associated with relevant routines.
+
+    :param windows: Primary class instance for window object.
+    """
+
+
+    attrs = list(windows.__dict__)
+
+    assert attrs == [
+        '_Windows__params',
+        '_Windows__start',
+        '_Windows__stop',
+        '_Windows__sqlite',
+        '_Windows__file',
+        '_Windows__table',
+        '_Windows__group',
+        '_Windows__windows']
+
+
+    assert inrepr(
+        'windows.Windows object',
+        windows)
+
+    assert hash(windows) > 0
+
+    assert instr(
+        'windows.Windows object',
+        windows)
+
+
+    assert windows.params is not None
+
+    assert windows.start == (
+        '1970-01-01T00:05:10Z')
+
+    assert windows.stop == (
+        '1970-01-01T00:10:10Z')
+
+    assert windows.sqlite is not None
+
+    assert windows.file[-8:] == 'cache.db'
+
+    assert windows.table == 'windows'
+
+    assert windows.group == 'default'
+
+    assert len(windows.children) == 2
+
+
+    window = windows.children['one']
+
+    assert window.next == (
+        '1970-01-01T00:06:00Z')
+
+    assert window.last == (
+        '1970-01-01T00:05:00Z')
+
+
+    window = windows.children['two']
+
+    assert window.next == (
+        '1970-01-01T00:08:00Z')
+
+    assert window.last == (
+        '1970-01-01T00:07:00Z')
+
+
+
+def test_Windows_cover(
+    windows: 'Windows',
+) -> None:
+    """
+    Perform various tests associated with relevant routines.
+
+    :param windows: Primary class instance for window object.
+    """
+
+
+    assert windows.ready('one')
+
+    assert windows.ready('two')
+
+
+    windows.update('two', '+1h')
+
+    assert not windows.ready('two')
+
+    windows.load_children()
+
+    assert windows.ready('two')
+
+
+    windows.update('two', '+1h')
+
+    assert not windows.ready('two')
+
+    windows.save_children()
+    windows.load_children()
+
+    assert not windows.ready('two')
+
+
+    params = WindowParams(
+        window='* * * * *',
+        start=310,
+        stop=610,
+        delay=10)
+
+    windows.create('fur', params)
+
+    assert windows.ready('fur')
+
+    windows.delete('fur')
+
+
+
+def test_Windows_raises(
+    windows: Windows,
+) -> None:
+    """
+    Perform various tests associated with relevant routines.
+
+    :param windows: Primary class instance for window object.
+    """
+
+
+    _raises = raises(ValueError)
+
+    with _raises as reason:
+        windows.ready('dne')
+
+    _reason = str(reason.value)
+
+    assert _reason == 'unique'
+
+
+    _raises = raises(ValueError)
+
+    params = WindowParams(
+        window='* * * * *')
+
+    with _raises as reason:
+        windows.create('one', params)
+
+    _reason = str(reason.value)
+
+    assert _reason == 'unique'
+
+
+    _raises = raises(ValueError)
+
+    with _raises as reason:
+        windows.update('dne', 'now')
+
+    _reason = str(reason.value)
+
+    assert _reason == 'unique'
+
+
+    _raises = raises(ValueError)
+
+    with _raises as reason:
+        windows.delete('dne')
+
+    _reason = str(reason.value)
+
+    assert _reason == 'unique'

encommon/times/timer.py

@@ -0,0 +1,147 @@
+"""
+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 Optional
+
+from .common import NUMERIC
+from .common import PARSABLE
+from .times import Times
+
+
+
+class Timer:
+    """
+    Process and operate the timer using provided interval.
+
+    .. testsetup::
+       >>> from time import sleep
+
+    Example
+    -------
+    >>> timer = Timer(1)
+    >>> timer.ready()
+    False
+    >>> sleep(1)
+    >>> timer.ready()
+    True
+
+    :param seconds: Period of time which must pass in timer.
+    :param started: Override default of using current time.
+    """
+
+    __timer: float
+    __times: Times
+
+
+    def __init__(
+        self,
+        timer: NUMERIC,
+        *,
+        start: Optional[PARSABLE] = None,
+    ) -> None:
+        """
+        Initialize instance for class using provided parameters.
+        """
+
+        timer = float(timer)
+        start = Times(start)
+
+        self.__timer = timer
+        self.__times = start
+
+
+    @property
+    def timer(
+        self,
+    ) -> float:
+        """
+        Return the value for the attribute from class instance.
+
+        :returns: Value for the attribute from class instance.
+        """
+
+        return self.__timer
+
+
+    @property
+    def times(
+        self,
+    ) -> Times:
+        """
+        Return the value for the attribute from class instance.
+
+        :returns: Value for the attribute from class instance.
+        """
+
+        return self.__times
+
+
+    @property
+    def since(
+        self,
+    ) -> float:
+        """
+        Return the seconds that have elapsed since the interval.
+
+        :returns: Seconds that have elapsed since the interval.
+        """
+
+        return self.times.since
+
+
+    @property
+    def remains(
+        self,
+    ) -> float:
+        """
+        Return the value for the attribute from class instance.
+
+        :returns: Value for the attribute from class instance.
+        """
+
+        timer = self.timer
+        since = self.since
+
+        return max(0.0, timer - since)
+
+
+    def ready(
+        self,
+        update: bool = True,
+    ) -> bool:
+        """
+        Determine whether or not the appropriate time has passed.
+
+        :param update: Determines whether or not time is updated.
+        :returns: Boolean indicating whether enough time passed.
+        """
+
+        if self.remains > 0:
+            return False
+
+        if update is True:
+            self.update('now')
+
+        return True
+
+
+    def update(
+        self,
+        value: Optional[PARSABLE] = None,
+    ) -> None:
+        """
+        Update the timer from the provided parasable time value.
+
+        :param value: Override the time updated for timer value.
+        """
+
+        value = Times(
+            value or 'now')
+
+        self.__times = value