TheSandmanAJM 0.1__tar.gz

thesandmanajm-0.1/LICENSE.txt

@@ -0,0 +1,17 @@
+MIT License
+Copyright (c) 2018 Andrew McSparron
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

thesandmanajm-0.1/PKG-INFO

@@ -0,0 +1,34 @@
+Metadata-Version: 2.4
+Name: TheSandmanAJM
+Version: 0.1
+Summary: A utility class to facilitate and log time delays with custom sleep durations.
+Home-page: https://github.com/amcsparron2793-Water/TheSandmanAJM
+Download-URL: https://github.com/amcsparron2793-Water/TheSandmanAJM/archive/refs/tags/0.1.tar.gz
+Author: Amcsparron
+Author-email: amcsparron@albanyny.gov
+License: MIT License
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Topic :: Software Development :: Build Tools
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Description-Content-Type: text/markdown
+License-File: LICENSE.txt
+Requires-Dist: tqdm
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: download-url
+Dynamic: home-page
+Dynamic: license
+Dynamic: license-file
+Dynamic: requires-dist
+Dynamic: summary
+
+# <u>TheSandmanAJM</u>
+### <i>A utility class to facilitate and log time delays with custom sleep durations.</i>
+
+
+A utility class to facilitate and log time delays with custom sleep durations.

thesandmanajm-0.1/README.md

@@ -0,0 +1,5 @@
+# <u>TheSandmanAJM</u>
+### <i>A utility class to facilitate and log time delays with custom sleep durations.</i>
+
+
+A utility class to facilitate and log time delays with custom sleep durations.

thesandmanajm-0.1/TheSandmanAJM/__init__.py

@@ -0,0 +1,2 @@
+from TheSandmanAJM.the_sandman import TheSandman
+__all__ = ['TheSandman']

thesandmanajm-0.1/TheSandmanAJM/_version.py

@@ -0,0 +1 @@
+__version__ = '0.1'

thesandmanajm-0.1/TheSandmanAJM/the_sandman.py

@@ -0,0 +1,119 @@
+from datetime import datetime
+from logging import getLogger, Logger
+from time import sleep
+
+from tqdm import tqdm
+
+
+class TheSandman:
+    """
+        A utility class to facilitate and log time delays with custom sleep durations.
+
+        Attributes:
+            DEFAULT_SLEEP_TIME_SECONDS (int): Default sleep duration in seconds if not specified.
+            sleep_time (int): Actual sleep time (in seconds) to be used by the instance.
+            sleep_time_string (str): Human-readable string representing the current sleep duration.
+            logger (Logger): Logging instance for logging messages related to sleep operations.
+
+        Methods:
+            sleep_time_string:
+                Property getter and setter for updating the human-readable sleep time string.
+
+            sleep_round():
+                Splits the sleep duration into two equal parts. It logs and prints messages depicting the current sleep state, including the remaining time, and sleeps for the given durations.
+    """
+    # default 600 secs = 10 minutes
+    DEFAULT_SLEEP_TIME_SECONDS = 600
+    DEFAULT_USE_VISUAL_SLEEP = True
+    DEFAULT_SILENT_SLEEP = False
+
+    def __init__(self, sleep_time_seconds=None, **kwargs):
+        self.sleep_time_start = None
+        self.use_visual_sleep = kwargs.get('use_visual_sleep', self.__class__.DEFAULT_USE_VISUAL_SLEEP)
+        self.silent_sleep = kwargs.get('silent_sleep', self.__class__.DEFAULT_SILENT_SLEEP)
+
+        self.sleep_time: int = sleep_time_seconds or self.__class__.DEFAULT_SLEEP_TIME_SECONDS
+        self._is_time_remaining = False
+        self._sleep_time_string = None
+
+        self.logger: Logger = kwargs.get('logger', getLogger(__name__))
+        self.sleep_time_string = self.sleep_time
+        self.logger.info(f'TheSandman initialized - sleep time set as {self.sleep_time_string}')
+
+    @property
+    def sleep_time_string(self):
+        return self._sleep_time_string
+
+    @sleep_time_string.setter
+    def sleep_time_string(self, value: int):
+        if self._is_time_remaining:
+            more = 'more'
+        else:
+            more = ''
+        if value >= 60:
+            self._sleep_time_string = f'sleeping for {value // 60} {more} minute(s)'
+        else:
+            self._sleep_time_string = f'sleeping for {value} {more} second(s)'
+
+        str_parts = [self._sleep_time_string, f'(started at {self.sleep_time_start})']
+        self._sleep_time_string = ' '.join(str_parts)
+
+    def _setup_sleep_in_rounds(self, **kwargs):
+        self.sleep_time_start = datetime.now().strftime('%m/%d/%Y %H:%M')
+        if self.use_visual_sleep:
+            kwargs['print_msg'] = False
+        elif self.silent_sleep:
+            kwargs['print_msg'] = False
+        else:
+            kwargs['print_msg'] = True
+        self._is_time_remaining = False
+        return kwargs
+
+    def _sleep_round(self, curr_sleep_round: int, total_rounds: int, print_msg: bool, **kwargs):
+        if curr_sleep_round == total_rounds - 1:
+            self._is_time_remaining = True
+        sleep_time_seconds = (self.sleep_time // total_rounds)
+        self.sleep(sleep_time_seconds, print_msg=print_msg, **kwargs)
+
+    def sleep_in_rounds(self, rounds=2, **kwargs):
+        kwargs = self._setup_sleep_in_rounds(**kwargs)
+
+        for sleep_round in range(rounds):
+            self._sleep_round(sleep_round, rounds, **kwargs)
+
+    def visual_sleep(self, sleep_time_seconds: int) -> None:
+        try:
+            for _ in tqdm(range(sleep_time_seconds),
+                          desc=f"{self.sleep_time_string}",
+                          unit="second"):
+                sleep(1)
+        except Exception as e:
+            if e.__class__.__name__ != 'KeyboardInterrupt':
+                self.logger.error(f"visual_sleep failed: {e}, turning off visual sleep and trying again...")
+                self.use_visual_sleep = False
+                self.sleep(sleep_time_seconds)
+            else:
+                raise
+
+    def sleep(self, sleep_time_seconds: int, **kwargs):
+        """
+        :param sleep_time_seconds: The number of seconds the function should pause execution.
+        :type sleep_time_seconds: int
+        :return: None
+        :rtype: None
+        """
+
+        self.sleep_time_string = self.sleep_time if not self._is_time_remaining else sleep_time_seconds
+        self.logger.info(self.sleep_time_string, **kwargs)
+
+        if self.use_visual_sleep:
+            self.visual_sleep(sleep_time_seconds)
+        else:
+            if not self.silent_sleep:
+                print(self.sleep_time_string)
+            sleep(sleep_time_seconds)
+
+
+if __name__ == '__main__':
+    ts = TheSandman(sleep_time_seconds=30)
+    ts.sleep_in_rounds(rounds=3)

thesandmanajm-0.1/TheSandmanAJM.egg-info/PKG-INFO

@@ -0,0 +1,34 @@
+Metadata-Version: 2.4
+Name: TheSandmanAJM
+Version: 0.1
+Summary: A utility class to facilitate and log time delays with custom sleep durations.
+Home-page: https://github.com/amcsparron2793-Water/TheSandmanAJM
+Download-URL: https://github.com/amcsparron2793-Water/TheSandmanAJM/archive/refs/tags/0.1.tar.gz
+Author: Amcsparron
+Author-email: amcsparron@albanyny.gov
+License: MIT License
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Topic :: Software Development :: Build Tools
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Description-Content-Type: text/markdown
+License-File: LICENSE.txt
+Requires-Dist: tqdm
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: download-url
+Dynamic: home-page
+Dynamic: license
+Dynamic: license-file
+Dynamic: requires-dist
+Dynamic: summary
+
+# <u>TheSandmanAJM</u>
+### <i>A utility class to facilitate and log time delays with custom sleep durations.</i>
+
+
+A utility class to facilitate and log time delays with custom sleep durations.

thesandmanajm-0.1/TheSandmanAJM.egg-info/SOURCES.txt

@@ -0,0 +1,14 @@
+LICENSE.txt
+README.md
+pyproject.toml
+setup.cfg
+setup.py
+TheSandmanAJM/__init__.py
+TheSandmanAJM/_version.py
+TheSandmanAJM/the_sandman.py
+TheSandmanAJM.egg-info/PKG-INFO
+TheSandmanAJM.egg-info/SOURCES.txt
+TheSandmanAJM.egg-info/dependency_links.txt
+TheSandmanAJM.egg-info/requires.txt
+TheSandmanAJM.egg-info/top_level.txt
+tests/test_the_sandman.py

thesandmanajm-0.1/TheSandmanAJM.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

thesandmanajm-0.1/TheSandmanAJM.egg-info/requires.txt

@@ -0,0 +1 @@
+tqdm

thesandmanajm-0.1/TheSandmanAJM.egg-info/top_level.txt

@@ -0,0 +1 @@
+TheSandmanAJM

thesandmanajm-0.1/pyproject.toml

@@ -0,0 +1,3 @@
+[build-system]
+requires = ["setuptools"]
+build-backend = "setuptools.build_meta"

thesandmanajm-0.1/setup.cfg

@@ -0,0 +1,7 @@
+[metadata]
+description_file = README.md
+
+[egg_info]
+tag_build = 
+tag_date = 0
+

thesandmanajm-0.1/setup.py

@@ -0,0 +1,45 @@
+from setuptools import setup
+from pathlib import Path
+import re
+
+project_name = 'TheSandmanAJM'
+
+
+def get_long_description():
+    this_dir = Path(__file__).parent
+    readme_path = this_dir / "README.md"
+    if readme_path.is_file():
+        long_description = (this_dir / "README.md").read_text()
+    else:
+        long_description = 'A utility class to facilitate and log time delays with custom sleep durations.'
+    return long_description
+
+
+def get_property(prop, project):
+    result = re.search(r'{}\s*=\s*[\'"]([^\'"]*)[\'"]'.format(prop), open(project + '/_version.py').read())
+    return result.group(1)
+
+
+setup(
+    name=project_name,
+    version=get_property('__version__', project_name),
+    packages=['TheSandmanAJM'],
+    url='https://github.com/amcsparron2793-Water/TheSandmanAJM',
+    download_url=f'https://github.com/amcsparron2793-Water/TheSandmanAJM/archive/refs/tags/{get_property("__version__", project_name)}.tar.gz',
+    keywords=[],
+    install_requires=['tqdm'],
+    license='MIT License',
+    author='Amcsparron',
+    author_email='amcsparron@albanyny.gov',
+    description='A utility class to facilitate and log time delays with custom sleep durations.',
+    long_description=get_long_description(),
+    long_description_content_type='text/markdown',
+    # this is for pypi categories etc
+    classifiers=[
+        'Development Status :: 3 - Alpha',      # Chose either "3 - Alpha", "4 - Beta" or "5 - Production/Stable" as the current state of your package
+        'Intended Audience :: Developers',      # Define that your audience are developers
+        'Topic :: Software Development :: Build Tools',
+        'License :: OSI Approved :: MIT License',   # Again, pick a license
+        'Programming Language :: Python :: 3',      # Specify which python versions that you want to support
+    ]
+)

thesandmanajm-0.1/tests/test_the_sandman.py

@@ -0,0 +1,104 @@
+import pytest
+from unittest.mock import patch, MagicMock
+from TheSandmanAJM.the_sandman import TheSandman
+
+
+@pytest.fixture
+def mock_logger():
+    return MagicMock()
+
+
+@pytest.fixture
+def sandman(mock_logger):
+    return TheSandman(sleep_time_seconds=10, logger=mock_logger)
+
+
+def test_initialization_defaults():
+    ts = TheSandman()
+    assert ts.sleep_time == 600
+    assert ts.use_visual_sleep is True
+    assert ts.silent_sleep is False
+
+
+def test_initialization_custom():
+    ts = TheSandman(sleep_time_seconds=30, use_visual_sleep=False, silent_sleep=True)
+    assert ts.sleep_time == 30
+    assert ts.use_visual_sleep is False
+    assert ts.silent_sleep is True
+
+
+def test_sleep_time_string_seconds(sandman):
+    sandman.sleep_time_start = "2026-08-23 14:30"
+    sandman.sleep_time_string = 45
+    assert "sleeping for 45  second(s)" in sandman.sleep_time_string
+    assert "(started at 2026-08-23 14:30)" in sandman.sleep_time_string
+
+
+def test_sleep_time_string_minutes(sandman):
+    sandman.sleep_time_start = "2026-08-23 14:30"
+    sandman.sleep_time_string = 125
+    assert "sleeping for 2  minute(s)" in sandman.sleep_time_string
+
+
+def test_sleep_time_string_with_remaining(sandman):
+    sandman.sleep_time_start = "2026-08-23 14:30"
+    sandman._is_time_remaining = True
+    sandman.sleep_time_string = 30
+    assert "sleeping for 30 more second(s)" in sandman.sleep_time_string
+
+
+def test_setup_sleep_in_rounds(sandman):
+    kwargs = sandman._setup_sleep_in_rounds(extra="data")
+    assert sandman.sleep_time_start is not None
+    assert sandman._is_time_remaining is False
+    assert kwargs['extra'] == "data"
+    # Since use_visual_sleep is True by default, print_msg should be False
+    assert kwargs['print_msg'] is False
+
+
+@patch('TheSandmanAJM.the_sandman.sleep')
+@patch('builtins.print')
+def test_sleep_non_visual(mock_print, mock_sleep, sandman, mock_logger):
+    sandman.use_visual_sleep = False
+    sandman.silent_sleep = False
+    sandman.sleep(5)
+    mock_sleep.assert_called_once_with(5)
+    mock_print.assert_called_once()
+    mock_logger.info.assert_called()
+
+
+@patch('TheSandmanAJM.the_sandman.TheSandman.visual_sleep')
+def test_sleep_visual_calls_visual_sleep(mock_visual_sleep, sandman):
+    sandman.use_visual_sleep = True
+    sandman.sleep(5)
+    mock_visual_sleep.assert_called_once_with(5)
+
+
+@patch('TheSandmanAJM.the_sandman.tqdm')
+@patch('TheSandmanAJM.the_sandman.sleep')
+def test_visual_sleep(mock_sleep, mock_tqdm, sandman):
+    # Mock tqdm to return a mock range
+    mock_tqdm.return_value = range(5)
+    sandman.visual_sleep(5)
+    assert mock_sleep.call_count == 5
+    mock_tqdm.assert_called_once()
+
+
+@patch('TheSandmanAJM.the_sandman.TheSandman.sleep')
+def test_sleep_in_rounds(mock_ts_sleep, sandman):
+    sandman.sleep_time = 30
+    sandman.sleep_in_rounds(rounds=3)
+    assert mock_ts_sleep.call_count == 3
+    # 30 // 3 = 10
+    mock_ts_sleep.assert_called_with(10, print_msg=False)
+
+
+@patch('TheSandmanAJM.the_sandman.tqdm')
+@patch('TheSandmanAJM.the_sandman.TheSandman.sleep')
+def test_visual_sleep_exception_fallback(mock_ts_sleep, mock_tqdm, sandman, mock_logger):
+    mock_tqdm.side_effect = Exception("tqdm error")
+    sandman.use_visual_sleep = True
+    sandman.visual_sleep(5)
+    assert sandman.use_visual_sleep is False
+    mock_ts_sleep.assert_called_once_with(5)
+    mock_logger.error.assert_called()