bear-utils 0.7.11__tar.gz → 0.7.12__tar.gz

{bear_utils-0.7.11 → bear_utils-0.7.12}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: bear-utils
-Version: 0.7.11
+Version: 0.7.12
 Summary: Various utilities for Bear programmers, including a rich logging utility, a disk cache, and a SQLite database wrapper amongst other things.
 Author: chaz
 Author-email: bright.lid5647@fastmail.com
@@ -8,6 +8,7 @@ Requires-Python: >=3.12
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
+Requires-Dist: bear-epoch-time (>=1.0.1)
 Requires-Dist: diskcache (>=5.6.3,<6.0.0)
 Requires-Dist: httpx (>=0.28.1)
 Requires-Dist: pathspec (>=0.12.1)
@@ -16,14 +17,13 @@ Requires-Dist: prompt-toolkit (>=3.0.51,<4.0.0)
 Requires-Dist: pydantic (>=2.11.5)
 Requires-Dist: pyglm (>=2.8.2,<3.0.0)
 Requires-Dist: pyqt6 (>=6.9.0)
-Requires-Dist: pytz (>=2025.2)
 Requires-Dist: pyyaml (>=6.0.2)
 Requires-Dist: rich (>=14.0.0,<15.0.0)
 Requires-Dist: singleton-base (>=1.0.5)
 Requires-Dist: sqlalchemy (>=2.0.40,<3.0.0)
 Description-Content-Type: text/markdown
 
-# Bear Utils v# Bear Utils v0.7.11
+# Bear Utils v# Bear Utils v0.7.12
 
 Personal set of tools and utilities for Python projects, focusing on modularity and ease of use. This library includes components for caching, database management, logging, time handling, file operations, CLI prompts, image processing, clipboard interaction, gradient utilities, event systems, and async helpers.
 

{bear_utils-0.7.11 → bear_utils-0.7.12}/README.md

@@ -1,4 +1,4 @@
-# Bear Utils v# Bear Utils v0.7.11
+# Bear Utils v# Bear Utils v0.7.12
 
 Personal set of tools and utilities for Python projects, focusing on modularity and ease of use. This library includes components for caching, database management, logging, time handling, file operations, CLI prompts, image processing, clipboard interaction, gradient utilities, event systems, and async helpers.
 

{bear_utils-0.7.11 → bear_utils-0.7.12}/pyproject.toml

@@ -1,10 +1,8 @@
 [project]
 name = "bear-utils"
-version = "0.7.11"
+version = "0.7.12"
 description = "Various utilities for Bear programmers, including a rich logging utility, a disk cache, and a SQLite database wrapper amongst other things."
-authors = [
-    { name = "chaz", email = "bright.lid5647@fastmail.com" }
-]
+authors = [{ name = "chaz", email = "bright.lid5647@fastmail.com" }]
 readme = "README.md"
 requires-python = ">=3.12"
 dependencies = [
@@ -18,12 +16,11 @@ dependencies = [
     "pydantic>=2.11.5",
     "pathspec>=0.12.1",
     "pyyaml>=6.0.2",
-    "pytz>=2025.2",
     "singleton-base>=1.0.5",
     "httpx>=0.28.1",
+    "bear-epoch-time>=1.0.1",
 ]
 
-
 [build-system]
 requires = ["poetry-core>=2.0.0,<3.0.0"]
 build-backend = "poetry.core.masonry.api"
@@ -36,7 +33,6 @@ dev = [
     "twine>=6.1.0",
 ]
 
-
 [tool.pytest.ini_options]
 markers = [
     "visual: marks tests as visual verification tests (deselect with '-m \"not visual\"')"

{bear_utils-0.7.11 → bear_utils-0.7.12}/src/bear_utils/__init__.py

@@ -1,3 +1,5 @@
+from bear_epoch_time import EpochTimestamp, TimeTools
+
 from .cache import CacheWrapper, cache, cache_factory
 from .config.settings_manager import SettingsManager, get_settings_manager
 from .constants.date_related import DATE_FORMAT, DATE_TIME_FORMAT
@@ -7,7 +9,5 @@ from .files.file_handlers.file_handler_factory import FileHandlerFactory
 from .logging.logger_manager._common import VERBOSE_CONSOLE_FORMAT
 from .logging.logger_manager._styles import VERBOSE
 from .logging.loggers import BaseLogger, BufferLogger, ConsoleLogger, FileLogger
-from .time._time_class import EpochTimestamp
-from .time.time_manager import TimeTools
 
-__version__ = "__version__ = "0.7.11""
+__version__ = "0.7.12"

bear_utils-0.7.12/src/bear_utils/constants/date_related.py

@@ -0,0 +1 @@
+from bear_epoch_time.constants.date_related import DATE_FORMAT, DATE_TIME_FORMAT

{bear_utils-0.7.11 → bear_utils-0.7.12}/src/bear_utils/extras/__init__.py

@@ -1,3 +1,5 @@
+from singleton_base import SingletonBase
+
 from ._tools import ClipboardManager, clear_clipboard, copy_to_clipboard, fmt_header, paste_from_clipboard
 from .platform_utils import OS, get_platform, is_linux, is_macos, is_windows
 from .wrappers.add_methods import add_comparison_methods
@@ -14,4 +16,5 @@ __all__ = [
     "clear_clipboard",
     "fmt_header",
     "add_comparison_methods",
+    "SingletonBase",
 ]

{bear_utils-0.7.11 → bear_utils-0.7.12}/src/bear_utils/logging/logger_manager/_styles.py

@@ -85,7 +85,9 @@ def get_method(name: str) -> LoggerExtraInfo:
     return LOGGER_METHODS[name]
 
 
-DEFAULT_STYLES: dict[str, str] = {**{method: info["style"].upper() for method, info in LOGGER_METHODS.items()}}
+DEFAULT_STYLES: dict[str, str] = {**{method: info["style"] for method, info in LOGGER_METHODS.items()}}
 """Just the styles of the logger methods, used to create the theme."""
 
 DEFAULT_THEME = Theme(styles=DEFAULT_STYLES)
+
+print(DEFAULT_STYLES)

bear_utils-0.7.12/src/bear_utils/time/__init__.py

@@ -0,0 +1,13 @@
+from bear_epoch_time import EpochTimestamp, TimerData, TimeTools, add_ord_suffix, create_timer, timer
+from bear_epoch_time.constants.date_related import DATE_FORMAT, DATE_TIME_FORMAT
+
+__all__ = [
+    "EpochTimestamp",
+    "TimerData",
+    "create_timer",
+    "timer",
+    "TimeTools",
+    "add_ord_suffix",
+    "DATE_FORMAT",
+    "DATE_TIME_FORMAT",
+]

bear_utils-0.7.11/src/bear_utils/constants/date_related.py

@@ -1,36 +0,0 @@
-from typing import LiteralString
-
-from pytz import UTC, timezone
-from pytz.tzinfo import BaseTzInfo, DstTzInfo, StaticTzInfo
-
-TimeZoneType = BaseTzInfo | DstTzInfo | StaticTzInfo
-
-DATE_FORMAT = "%m-%d-%Y"
-"""Date format"""
-
-TIME_FORMAT = "%I:%M %p"
-"""Time format with 12 hour format"""
-
-TIME_FORMAT_WITH_SECONDS: LiteralString = "%I:%M:%S %p"
-"""Time format with 12 hour format and seconds"""
-
-DATE_TIME_FORMAT: LiteralString = f"{DATE_FORMAT} {TIME_FORMAT}"
-"""Datetime format with 12 hour format"""
-
-DT_FORMAT_WITH_SECONDS: LiteralString = f"{DATE_FORMAT} {TIME_FORMAT_WITH_SECONDS}"
-"""Datetime format with 12 hour format and seconds"""
-
-DT_FORMAT_WITH_TZ: LiteralString = f"{DATE_TIME_FORMAT} %Z"
-"""Datetime format with 12 hour format and timezone"""
-
-DT_FORMAT_WITH_TZ_AND_SECONDS: LiteralString = f"{DT_FORMAT_WITH_SECONDS} %Z"
-"""Datetime format with 12 hour format, seconds, and timezone"""
-
-PT_TIME_ZONE: TimeZoneType = timezone("America/Los_Angeles")
-"""Default timezone, a Pacific Time Zone using a pytz timezone object"""
-
-UTC_TIME_ZONE: TimeZoneType = UTC
-"""UTC timezone, a UTC timezone using a pytz timezone object"""
-
-CEST_TIME_ZONE: TimeZoneType = timezone("Europe/Berlin")  # Central European Summer Time, I GUESS!
-"""Central European Summer Time timezone, a CEST timezone using a pytz timezone object"""

bear_utils-0.7.11/src/bear_utils/time/__init__.py

@@ -1,16 +0,0 @@
-from ..constants.date_related import DATE_FORMAT, DATE_TIME_FORMAT
-from ._time_class import EpochTimestamp
-from ._timer import TimerData, create_timer, timer
-from ._tools import add_ord_suffix
-from .time_manager import TimeTools
-
-__all__ = [
-    "EpochTimestamp",
-    "TimerData",
-    "create_timer",
-    "timer",
-    "TimeTools",
-    "add_ord_suffix",
-    "DATE_FORMAT",
-    "DATE_TIME_FORMAT",
-]

bear_utils-0.7.11/src/bear_utils/time/_helpers.py

@@ -1,91 +0,0 @@
-import re
-from datetime import timedelta
-
-from ..constants.time_related import SECONDS_IN_DAY, SECONDS_IN_HOUR, SECONDS_IN_MINUTE, SECONDS_IN_MONTH
-
-
-def convert_to_seconds(time_str: str) -> int:
-    """Convert a time string to seconds.
-
-    Examples
-    --------
-    >>> convert_to_seconds("1M 30m")
-    2610000
-
-    Notes
-    -----
-    * ``M`` or ``mo`` denotes **months**.
-    * ``m`` denotes **minutes**.
-    """
-
-    time_parts: list[tuple[str, str]] = re.findall(r"(\d+)\s*(M|mo|[dhms])", time_str)
-    total_seconds = 0
-    for value, unit in time_parts:
-        if not value.isdigit():
-            raise ValueError(f"Invalid time value: {value}")
-        value = int(value)
-
-        if unit == "M" or unit.lower() == "mo":
-            total_seconds += value * SECONDS_IN_MONTH
-        elif unit == "d":
-            total_seconds += value * SECONDS_IN_DAY
-        elif unit == "h":
-            total_seconds += value * SECONDS_IN_HOUR
-        elif unit == "m":
-            total_seconds += value * SECONDS_IN_MINUTE
-        elif unit == "s":
-            total_seconds += value
-        else:
-            raise ValueError(f"Invalid time unit: {unit}")
-    return total_seconds
-
-
-def timedelta_to_seconds(td: timedelta) -> int:
-    """Convert a timedelta object to seconds."""
-    if not isinstance(td, timedelta):
-        raise ValueError("Input must be a timedelta object")
-    return int(td.total_seconds())
-
-
-def convert_to_milliseconds(time_str: str) -> int:
-    return convert_to_seconds(time_str) * 1000
-
-
-def milliseconds_to_time(milliseconds: int) -> str:
-    """Convert milliseconds to a human-readable time string."""
-    if milliseconds < 0:
-        raise ValueError("Milliseconds cannot be negative")
-    seconds = milliseconds // 1000
-    return seconds_to_time(seconds)
-
-
-def seconds_to_timedelta(seconds: int) -> timedelta:
-    """Convert seconds to a timedelta object."""
-    if seconds < 0:
-        raise ValueError("Seconds cannot be negative")
-    return timedelta(seconds=seconds)
-
-
-def seconds_to_time(seconds: int) -> str:
-    """Convert seconds to a human-readable time string.
-
-    Months are represented with ``M`` while minutes use ``m``.
-    """
-    if seconds < 0:
-        raise ValueError("Seconds cannot be negative")
-    months, reminder = divmod(seconds, SECONDS_IN_MONTH)
-    days, reminder = divmod(reminder, SECONDS_IN_DAY)
-    hours, reminder = divmod(reminder, SECONDS_IN_HOUR)
-    minutes, seconds = divmod(reminder, SECONDS_IN_MINUTE)
-    time_parts = []
-    if months > 0:
-        time_parts.append(f"{months}M")
-    if days > 0:
-        time_parts.append(f"{days}d")
-    if hours > 0:
-        time_parts.append(f"{hours}h")
-    if minutes > 0:
-        time_parts.append(f"{minutes}m")
-    if seconds > 0:
-        time_parts.append(f"{seconds}s")
-    return " ".join(time_parts)

bear_utils-0.7.11/src/bear_utils/time/_time_class.py

@@ -1,316 +0,0 @@
-from datetime import datetime
-from typing import ClassVar, Literal, Self
-
-from pytz import UTC
-
-from ..constants.date_related import DATE_FORMAT, DT_FORMAT_WITH_TZ, PT_TIME_ZONE, TIME_FORMAT, TimeZoneType
-
-REPR_CHOICES = Literal["int", "object", "datetime"]
-MULT = Literal[1000, 1]
-
-
-class EpochTimestamp(int):
-    """
-    Custom class to represent epoch timestamps.
-    Inherits from int to allow direct arithmetic operations.
-    This class is used to represent time in seconds or milliseconds since the epoch (1970-01-01 00:00:00 UTC)
-    with it defaulting to ms since that is the most common use case.
-
-    Default value is the current epoch time in milliseconds. It is suggested to set the value to 0 if using it as
-    a placeholder value or call `now()` to get the current epoch time.
-    """
-
-    _repr_style: ClassVar[REPR_CHOICES] = "int"
-    """Three choices: int, object, or datetime.
-    Int is the default and is the most common use case.
-    Object will return the object representation of the class.
-    Datetime will return a human readable timestamp like "10-01-2025." """
-    _datefmt: ClassVar[str] = DATE_FORMAT
-    """The format of the default date string. Default is "%m-%d-%Y"."""
-    _timefmt: ClassVar[str] = TIME_FORMAT
-    """The format of the default time string. Default is "%I:%M %p"."""
-    _fullfmt: ClassVar[str] = DT_FORMAT_WITH_TZ
-    """The format of the default datetime string. Default is "%m-%d-%Y %I:%M %p %Z"."""
-    _tz: ClassVar[TimeZoneType] = PT_TIME_ZONE
-    """The default timezone for the class. Default is "America/Los_Angeles"."""
-
-    # region Class Methods
-
-    @classmethod
-    def set_repr_style(cls, repr_style: REPR_CHOICES) -> None:
-        """
-        Set the plain representation of the class.
-
-        Args:
-            repr_style (str): The representation style ("int", "object", or "datetime")
-        """
-        cls._repr_style = repr_style
-
-    @classmethod
-    def set_date_format(cls, datefmt: str) -> None:
-        """
-        Set the default date format for the class.
-
-        Args:
-            datefmt (str): The format of the date string. Default is "%m-%d-%Y".
-        """
-        cls._datefmt = datefmt
-
-    @classmethod
-    def set_time_format(cls, timefmt: str) -> None:
-        """
-        Set the default time format for the class.
-
-        Args:
-            timefmt (str): The format of the time string. Default is "%I:%M %p".
-        """
-        cls._timefmt = timefmt
-
-    @classmethod
-    def set_full_format(cls, fullfmt: str) -> None:
-        """
-        Set the default datetime format for the class.
-
-        Args:
-            fullfmt (str): The format of the datetime string. Default is "%m-%d-%Y %I:%M %p %Z".
-        """
-        cls._fullfmt = fullfmt
-
-    @classmethod
-    def set_timezone(cls, tz: TimeZoneType) -> None:
-        """
-        Set the default timezone for the class.
-
-        Args:
-            tz (TimeZoneType): The timezone to set. Default is PT_TIME_ZONE.
-        """
-        cls._tz = tz
-
-    @classmethod
-    def now(cls, milliseconds: bool = True) -> Self:
-        """
-        Get the current epoch time in milliseconds or seconds in UTC.
-
-        Args:
-            milliseconds (bool): If True, return milliseconds. If False, return seconds. Default is True for milliseconds.
-
-        Returns:
-            EpochTimestamp: The current epoch time.
-        """
-        multiplier: MULT = 1000 if milliseconds else 1
-        t: int = int(datetime.now(UTC).timestamp()) * multiplier
-        return cls(t, milliseconds=milliseconds)
-
-    @classmethod
-    def from_datetime(cls, dt: datetime, milliseconds: bool = True) -> Self:
-        """
-        Convert a datetime object to an epoch timestamp.
-
-        Args:
-            dt (datetime): The datetime object to convert.
-            milliseconds (bool): If True, return milliseconds. If False, return seconds.
-
-        Returns:
-            EpochTimestamp: The epoch timestamp in milliseconds or seconds based on the milliseconds argument.
-        """
-        multiplier: MULT = 1000 if milliseconds else 1
-        return cls(int(dt.astimezone(UTC).timestamp() * multiplier), milliseconds=milliseconds)
-
-    @classmethod
-    def from_dt_string(cls, dt_string: str, milliseconds: bool = True, fmt: str | None = None) -> Self:
-        """
-        Convert a datetime string to an epoch timestamp.
-
-        Args:
-            dt_string (str): The datetime string to convert.
-            milliseconds (bool): If True, return milliseconds. If False, return seconds.
-            fmt (str): The format of the datetime string. Default is "%m-%d-%Y %I:%M %p".
-
-        Returns:
-            EpochTimestamp: The epoch timestamp in milliseconds or seconds based on the milliseconds argument.
-        """
-        multiplier: MULT = 1000 if milliseconds else 1
-        dt: datetime = datetime.strptime(dt_string, fmt if fmt else cls._fullfmt)
-        return cls(int(dt.astimezone(UTC).timestamp() * multiplier))
-
-    def __new__(cls, value: int | None = None, milliseconds: bool = True) -> Self:
-        value = value if value is not None else cls.now(milliseconds)
-        return super().__new__(cls, value)
-
-    # endregion
-
-    # region Instance Methods
-
-    def __init__(self, value: int | None = None, milliseconds: bool = True):
-        self.milliseconds = milliseconds
-        self.multiplier: MULT = 1000 if self.milliseconds else 1
-
-    def __str__(self):
-        return int.__str__(self)
-
-    def __repr__(self) -> str:
-        if self.is_default:
-            return "EpochTimestamp(0) (Default Value)"
-        match self._repr_style:
-            case "int":
-                return f"{int(self)}"
-            case "object":
-                return f"EpochTimestamp({int(self)})"
-            case "datetime":
-                return f"{self.to_datetime.strftime(self._datefmt)}"
-            case _:
-                raise ValueError(f"Invalid repr style: {self._repr_style}")
-
-    def to_string(self, fmt: str | None = None, tz: TimeZoneType | None = None) -> str:
-        """
-        Convert the epoch timestamp to a formatted string, taking into account the timezone and format.
-
-        Args:
-            fmt (str): The format of the datetime string. Default is "%m-%d-%Y %I:%M %p".
-            tz (TimeZoneType | None): The timezone to convert to. Default is PT_TIME_ZONE.
-
-        Returns:
-            str: The formatted date string.
-        """
-        if self.is_default:
-            raise ValueError("Cannot convert default value to string.")
-        fmt = fmt if fmt else self._fullfmt
-        tz = tz if tz else self._tz
-        return self.to_datetime.astimezone(tz).strftime(fmt)
-
-    def date_str(self, tz: TimeZoneType | None = None) -> str:
-        """
-        Convert the epoch timestamp to a date string in the format "%m-%d-%Y".
-
-        Args:
-            tz (TimeZoneType | None): The timezone to convert to. Default is PT_TIME_ZONE.
-
-        Returns:
-            str: The formatted date string.
-        """
-        return self.to_string(fmt=self._datefmt, tz=tz if tz else self._tz)
-
-    def time_str(self, tz: TimeZoneType | None = None) -> str:
-        """
-        Convert the epoch timestamp to a time string in the format "%I:%M %p".
-
-        Args:
-            tz (TimeZoneType | None): The timezone to convert to. Default is PT_TIME_ZONE.
-
-        Returns:
-            str: The formatted time string.
-        """
-        return self.to_string(fmt=self._timefmt, tz=tz if tz else self._tz)
-
-    def add_timedelta(self, seconds: int = 0, milliseconds: int = 0) -> Self:
-        """
-        Add a timedelta to the epoch timestamp.
-
-        Args:
-            seconds (int): The number of seconds to add. Default is 0.
-            milliseconds (int): The number of milliseconds to add. Default is 0.
-
-        Returns:
-            EpochTimestamp: The new epoch timestamp after adding the timedelta.
-        """
-        total_seconds = seconds + (milliseconds / 1000)
-        new_timestamp = int((self.to_seconds + total_seconds) * self.multiplier)
-        new_ts: Self = type(self)(new_timestamp)
-        return new_ts
-
-    def start_of_day(self, tz: TimeZoneType | None = None) -> Self:
-        """
-        Get the start of the day for the epoch timestamp, defaults to midnight of the day in UTC.
-
-        Args:
-            tz (TimeZoneType | None): The timezone to convert to. Will default to UTC if not provided.
-
-        Returns:
-            EpochTimestamp: The epoch timestamp at the start of the day.
-        """
-        dt: datetime = self.to_datetime.astimezone(tz) if tz else self.to_datetime
-        dt = dt.replace(hour=0, minute=0, second=0, microsecond=0)
-        return type(self).from_datetime(dt, milliseconds=self.milliseconds)
-
-    def end_of_day(self, tz: TimeZoneType | None = None) -> Self:
-        """
-        Get the end of the day for the epoch timestamp, defaults to 23:59:59.999999 of the day in UTC.
-
-        Args:
-            tz (TimeZoneType | None): The timezone to convert to. Will default to UTC if not provided.
-
-        Returns:
-            EpochTimestamp: The epoch timestamp at the end of the day.
-        """
-        dt: datetime = self.to_datetime.astimezone(tz) if tz else self.to_datetime
-        dt = dt.replace(hour=23, minute=59, second=59, microsecond=999999)
-        return type(self).from_datetime(dt, milliseconds=self.milliseconds)
-
-    # endregion
-
-    # region Properties
-
-    @property
-    def to_datetime(self) -> datetime:
-        """
-        Convert the epoch timestamp to a datetime object in UTC.
-
-        Returns:
-            datetime: The datetime representation of the epoch timestamp.
-        """
-        return datetime.fromtimestamp(self.to_seconds if self.milliseconds else self, tz=UTC)
-
-    @property
-    def to_seconds(self) -> int:
-        """
-        Get the total seconds from the epoch timestamp, if the timestamp is in milliseconds, it converts it to seconds else
-        just returns the integer value.
-
-        Returns:
-            int: The total seconds since the epoch.
-        """
-        return int(self // 1000) if self.milliseconds else int(self)
-
-    @property
-    def to_milliseconds(self) -> int:
-        """
-        Get the total milliseconds from the epoch timestamp, if the timestamp is in seconds, it converts it to milliseconds else
-        just returns the integer value.
-
-        Returns:
-            int: The total milliseconds since the epoch.
-        """
-        return int(self * 1000) if not self.milliseconds else int(self)
-
-    @property
-    def to_int(self) -> int:
-        """
-        Converts the epoch timestamp to an integer value. Mostly used for type hinting since this *IS* an int.
-
-        Returns:
-            int: The total milliseconds since the epoch.
-        """
-        return int(self)
-
-    @property
-    def is_default(self) -> bool:
-        """
-        Check if the timestamp is zero, this is useful since zero is the default value.
-
-        Returns:
-            bool: True if the timestamp is zero, False otherwise.
-        """
-        return self == 0
-
-    # endregion
-
-
-# if __name__ == "__main__":
-#     # Example usage
-#     default_value = EpochTimestamp(0)
-#     ts = EpochTimestamp.now()
-#     t2 = EpochTimestamp.now(milliseconds=False)
-
-#     print(f"Default Zero Value = {default_value}")
-#     print(f"Current timestamp in milliseconds: {ts} {ts.milliseconds=}")
-#     print(f"Current timestamp in seconds: {t2} {t2.milliseconds=}")

bear_utils-0.7.11/src/bear_utils/time/_timer.py

@@ -1,80 +0,0 @@
-from collections.abc import Callable
-from contextlib import contextmanager
-from functools import wraps
-
-from ..logging import ConsoleLogger
-from ._time_class import EpochTimestamp
-
-
-def create_timer(**defaults):
-    """A way to set defaults for a frequently used timer decorator."""
-
-    def timer_decorator(func):
-        @wraps(func)
-        def wrapper(*args, **kwargs):
-            defaults["name"] = func.__name__
-            with timer(**defaults):
-                return func(*args, **kwargs)
-
-        return wrapper
-
-    return timer_decorator
-
-
-@contextmanager
-def timer(**kwargs):
-    data: TimerData = kwargs.get("data", None) or TimerData(kwargs=kwargs)
-    data.start()
-    try:
-        yield data
-    finally:
-        data.stop()
-
-
-class TimerData:
-    def __init__(self, **kwargs):
-        self.name: str = kwargs.get("name", "Default Timer")
-        self.start_time: EpochTimestamp = EpochTimestamp(0)
-        self.end_time: EpochTimestamp = EpochTimestamp(0)
-        self._raw_elapsed_time: EpochTimestamp = EpochTimestamp(0)
-        self.console: ConsoleLogger | None = self.get_console(kwargs.get("output", False))
-        self.callback: Callable | None = kwargs.get("callback", None)
-        self._style: str = kwargs.get("style", "bold green")
-
-    def get_console(self, to_console: bool) -> ConsoleLogger | None:
-        if to_console:
-            try:
-                console = ConsoleLogger.get_instance()  # will crash if nothing else has initialized ConsoleLogger
-            except RuntimeError:
-                console = ConsoleLogger()
-            return console
-
-    def start(self):
-        self.start_time = EpochTimestamp.now()
-
-    def send_callback(self):
-        if self.callback is not None:
-            self.callback(self)
-
-    def stop(self):
-        self.end_time = EpochTimestamp.now()
-        self._raw_elapsed_time = EpochTimestamp(self.end_time - self.start_time)
-        if self.callback:
-            self.send_callback()
-        if self.console:
-            self.console.print(f"[{self.name}] Elapsed time: {self.elapsed_seconds:.2f} seconds", style=self._style)
-
-    @property
-    def elapsed_milliseconds(self) -> int:
-        if self._raw_elapsed_time:
-            return self._raw_elapsed_time.to_milliseconds
-        return -1
-
-    @property
-    def elapsed_seconds(self) -> int:
-        if self._raw_elapsed_time:
-            return self._raw_elapsed_time.to_seconds
-        return -1
-
-
-__all__ = ["TimerData"]

bear_utils-0.7.11/src/bear_utils/time/_tools.py

@@ -1,17 +0,0 @@
-def add_ord_suffix(number: int) -> str:
-    """
-    Add an ordinal suffix to a given number, usually used for dates or rankings.
-
-    Parameters:
-    number: int - The number to add an ordinal suffix to.
-
-    Returns:
-    str - The number with its ordinal suffix.
-    """
-    suffix = ["th", "st", "nd", "rd", "th"][min(number % 10, 4)]
-    if 11 <= (number % 100) <= 13:
-        suffix = "th"
-    return f"{number}{suffix}"
-
-
-__all__ = ["add_ord_suffix"]

bear_utils-0.7.11/src/bear_utils/time/time_manager.py

@@ -1,218 +0,0 @@
-from datetime import UTC, datetime, timedelta
-
-from ..constants.date_related import DATE_FORMAT, DT_FORMAT_WITH_TZ, PT_TIME_ZONE, TIME_FORMAT, TimeZoneType
-from ._time_class import EpochTimestamp
-
-
-class TimeTools:
-    """
-    A utility class for managing time-related operations, including epoch timestamps, date formatting,
-    and timezone handling.
-
-    Attributes:
-        timezone (TimeZoneType): The timezone to use for date and time operations. Defaults to PT_TIME_ZONE.
-        datefmt (str): The format string for date and time formatting. Defaults to DT_FORMAT_WITH_TZ.
-    """
-
-    def __init__(self, timezone=PT_TIME_ZONE, datefmt=DT_FORMAT_WITH_TZ):
-        self.timezone: TimeZoneType = timezone
-        self.datefmt: str = datefmt
-
-    def now(self, as_str: bool = False) -> EpochTimestamp | str:
-        """
-        Get a UTC epoch timestamp in milliseconds or a formatted string of the current date and time.
-
-        Args:
-            as_str (bool): If True, return formatted string instead of timestamp.
-
-        Returns:
-            EpochTimestamp | str: The current epoch timestamp in milliseconds or formatted string.
-        """
-        if as_str:
-            return self.format_now
-        return EpochTimestamp.now()
-
-    @property
-    def format_now(self) -> str:
-        """
-        Get the current date and time as a formatted string.
-
-        Returns:
-            str: The current date and time as a formatted string.
-        """
-        return EpochTimestamp.now().to_string(fmt=self.datefmt, tz=self.timezone)
-
-    def dt_to_ts(self, dt: datetime) -> EpochTimestamp:
-        """
-        Convert a datetime object to an epoch timestamp in milliseconds.
-
-        Args:
-            dt (datetime): The datetime object to convert.
-
-        Returns:
-            EpochTimestamp: The epoch timestamp in milliseconds.
-        """
-        dt_str = dt.strftime(self.datefmt)
-        return EpochTimestamp.from_dt_string(dt_str, milliseconds=True, fmt=self.datefmt)
-
-    def str_to_ts(self, date_str: str, fmt: str | None = None) -> EpochTimestamp:
-        """
-        Convert a date string to an epoch timestamp in milliseconds.
-
-        Args:
-            date_str (str): The date string to convert.
-            fmt (str | None): Format string. Uses instance default if not provided.
-
-        Returns:
-            EpochTimestamp: The epoch timestamp in milliseconds.
-        """
-        format_str = fmt or self.datefmt
-        return EpochTimestamp.from_dt_string(date_str, milliseconds=True, fmt=format_str)
-
-    def ts_to_str(self, ts: EpochTimestamp) -> str:
-        """
-        Convert an epoch timestamp to a formatted date string.
-
-        Args:
-            ts (EpochTimestamp): The epoch timestamp to convert.
-
-        Returns:
-            str: The formatted date string.
-        """
-        return ts.to_string(fmt=self.datefmt, tz=self.timezone)
-
-    def ts_to_dt(self, ts: EpochTimestamp) -> datetime:
-        """
-        Convert an epoch timestamp to a datetime object.
-
-        Args:
-            ts (EpochTimestamp): The epoch timestamp to convert.
-
-        Returns:
-            datetime: The datetime object.
-        """
-        return ts.to_datetime.astimezone(self.timezone)
-
-    def add_delta(
-        self,
-        ts: EpochTimestamp,
-        days: int = 0,
-        hours: int = 0,
-        minutes: int = 0,
-        seconds: int = 0,
-        dt_obj: timedelta | None = None,
-    ) -> EpochTimestamp:
-        """
-        Add a timedelta to an epoch timestamp.
-
-        Args:
-            ts (EpochTimestamp): The epoch timestamp to modify.
-            days (int): Number of days to add.
-            hours (int): Number of hours to add.
-            minutes (int): Number of minutes to add.
-            seconds (int): Number of seconds to add.
-            dt_obj (timedelta | None): A timedelta object to add (combined with other params).
-
-        Returns:
-            EpochTimestamp: The modified epoch timestamp.
-        """
-        if dt_obj:
-            if not isinstance(dt_obj, timedelta):
-                raise TypeError("timedelta_obj must be an instance of datetime.timedelta")
-            days += dt_obj.days
-            seconds += int(dt_obj.seconds + (dt_obj.microseconds / 1_000_000))
-        else:
-            seconds = seconds + (minutes * 60) + (hours * 3600) + (days * 86400)
-        return ts.add_timedelta(seconds=seconds)
-
-    def get_day_range(self, ts: EpochTimestamp | None = None) -> tuple[EpochTimestamp, EpochTimestamp]:
-        """
-        Get the start and end of a day from an epoch timestamp in the instance timezone, defaulting to now.
-
-        Args:
-            ts (EpochTimestamp): The epoch timestamp to convert (optional, defaults to now).
-
-        Returns:
-            tuple[EpochTimestamp, EpochTimestamp]: A tuple containing the start and end of the day as epoch timestamps.
-        """
-        if ts is None:
-            ts = EpochTimestamp.now()
-
-        timestamp_start: EpochTimestamp = ts.start_of_day(tz=self.timezone)
-        timestamp_end: EpochTimestamp = ts.end_of_day(tz=self.timezone)
-        return timestamp_start, timestamp_end
-
-    def is_same_day(self, start_date: EpochTimestamp, end_date: EpochTimestamp) -> bool:
-        """
-        Check if two epoch timestamps are on the same day.
-
-        Args:
-            start_date (EpochTimestamp): The first epoch timestamp.
-            end_date (EpochTimestamp): The second epoch timestamp.
-
-        Returns:
-            bool: True if both timestamps are on the same day, False otherwise.
-        """
-        dt1: datetime = datetime.fromtimestamp(start_date.to_seconds, tz=UTC)
-        dt2: datetime = datetime.fromtimestamp(end_date.to_seconds, tz=UTC)
-        return dt1.date() == dt2.date()
-
-    def is_multi_day(self, start_date: str | datetime, end_date: str | datetime) -> bool:
-        """Determines if the span between two dates covers multiple days.
-
-        Args:
-            start_date (str | datetime): The start date.
-            end_date (str | datetime): The end date.
-
-        Returns:
-            bool: If the span covers multiple days, return True. Else, return False.
-        """
-        if isinstance(start_date, str):
-            start_date = datetime.strptime(start_date, self.datefmt)
-        if isinstance(end_date, str):
-            end_date = datetime.strptime(end_date, self.datefmt)
-        return start_date.date() != end_date.date()
-
-    def time_only(self, ts: EpochTimestamp) -> str:
-        """
-        Get the time part of an epoch timestamp as a formatted string.
-
-        Args:
-            ts (EpochTimestamp): The epoch timestamp to convert.
-
-        Returns:
-            str: The time part of the timestamp.
-        """
-        return ts.to_string(fmt=TIME_FORMAT, tz=self.timezone)
-
-    def date_only(self, ts: EpochTimestamp) -> str:
-        """
-        Get the date part of an epoch timestamp as a formatted string.
-
-        Args:
-            ts (EpochTimestamp): The epoch timestamp to convert.
-
-        Returns:
-            str: The date part of the timestamp.
-        """
-        return ts.to_string(fmt=DATE_FORMAT, tz=self.timezone)
-
-
-# if __name__ == "__main__":
-
-#     # def example_callback(timer_data: TimerData):
-#     #     print(f"Timer '{timer_data.name}' finished in {timer_data._raw_elapsed_time} ms")
-
-#     # # Example usage
-#     # with timer(
-#     #     name="Tester Timer",
-#     #     console=True,
-#     # ) as time:
-#     #     sleep(2)  # Simulate some work
-#     #     data: TimerData = time
-
-#     # get start and end of day
-#     time_tools = TimeTools()
-#     start_of_day, end_of_day = time_tools.get_day_range()
-#     print(f"Start of day: {start_of_day.to_string()}")
-#     print(f"End of day: {end_of_day.to_string()}")