workclock 0.1.0__cp39-abi3-win_amd64.whl

workclock/__init__.py

@@ -0,0 +1,23 @@
+"""Fast, correct business-time arithmetic: working hours, SLAs and shifts."""
+
+from workclock._errors import (
+    NoWorkingTimeError,
+    OutOfRangeError,
+    UnknownZoneError,
+    WorkclockError,
+)
+from workclock._schedule import Break, Holidays, Rule, Schedule, WorkDay
+from workclock._workclock import __version__
+
+__all__ = [
+    "Break",
+    "Holidays",
+    "NoWorkingTimeError",
+    "OutOfRangeError",
+    "Rule",
+    "Schedule",
+    "UnknownZoneError",
+    "WorkDay",
+    "WorkclockError",
+    "__version__",
+]

workclock/_arrays.py

@@ -0,0 +1,84 @@
+"""NumPy support for the batch API, without depending on NumPy.
+
+NumPy is imported only when an array is passed in. ``datetime64`` values are
+naive, so they are read and returned as UTC.
+"""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+if TYPE_CHECKING:
+    import numpy as np
+    from numpy.typing import NDArray
+    from typing_extensions import TypeGuard
+
+_FINER_UNITS = ("ns", "ps", "fs", "as")
+
+
+def is_array(value: object) -> TypeGuard[NDArray[Any]]:
+    """Return whether ``value`` is a NumPy array."""
+    kind = type(value)
+    return kind.__module__ == "numpy" and kind.__name__ == "ndarray"
+
+
+def broadcast_shape(a: object, b: object) -> tuple[int, ...]:
+    """Return the shape that ``a`` and ``b`` broadcast to under NumPy's rules.
+
+    Raises ``ValueError`` naming both shapes if they do not broadcast.
+    """
+    import numpy as np
+
+    shapes = np.asarray(a).shape, np.asarray(b).shape
+    try:
+        return np.broadcast_shapes(*shapes)
+    except ValueError:
+        raise ValueError(
+            f"batch inputs of shapes {shapes[0]} and {shapes[1]} do not "
+            "broadcast together"
+        ) from None
+
+
+def to_micros(values: object, unit: str, shape: tuple[int, ...]) -> list[int]:
+    """Return ``values`` as integer microseconds, broadcast to ``shape``.
+
+    Raises ``TypeError`` for numbers, which carry no unit, ``ValueError`` for
+    NaT, and for values with digits below a microsecond, which would otherwise
+    be rounded.
+    """
+    import numpy as np
+
+    given = np.asarray(values)
+    if given.dtype.kind in "biufc":
+        raise TypeError(f"expected {unit} values, got {given.dtype} numbers")
+    converted: NDArray[Any] = np.asarray(values, dtype=f"{unit}[us]")
+    array = np.broadcast_to(converted, shape)
+    nat = np.flatnonzero(np.isnat(array))
+    if nat.size:
+        raise ValueError(f"item {nat[0]}: batch inputs must not contain NaT")
+    finer = (
+        given.dtype.kind in "mM" and np.datetime_data(given.dtype)[0] in _FINER_UNITS
+    )
+    if finer:
+        lossy = np.broadcast_to(converted.astype(given.dtype) != given, shape)
+        if lossy.any():
+            i = int(np.flatnonzero(lossy)[0])
+            value = np.broadcast_to(given, shape).flat[i]
+            raise ValueError(f"item {i}: {value!r} has digits below a microsecond")
+    result: list[int] = array.astype(np.int64).ravel().tolist()
+    return result
+
+
+def item(values: object, shape: tuple[int, ...], i: int) -> object:
+    """Return item ``i`` of ``values`` broadcast to ``shape`` and flattened."""
+    import numpy as np
+
+    return np.broadcast_to(np.asarray(values), shape).flat[i]
+
+
+def from_micros(micros: list[int], unit: str, shape: tuple[int, ...]) -> NDArray[Any]:
+    """Return integer microseconds as an array of ``unit`` with ``shape``."""
+    import numpy as np
+
+    array: NDArray[np.int64] = np.array(micros, dtype=np.int64).reshape(shape)
+    return array.astype(f"{unit}[us]")

workclock/_errors.py

@@ -0,0 +1,20 @@
+"""Exceptions raised by workclock."""
+
+
+class WorkclockError(Exception):
+    """Base class for workclock errors."""
+
+
+class NoWorkingTimeError(WorkclockError, ValueError):
+    """The schedule has no working time, or a search found none within its bound.
+
+    The bound is 366 days, plus seven days per holiday date.
+    """
+
+
+class OutOfRangeError(WorkclockError, OverflowError):
+    """An instant, amount or result is outside the supported range."""
+
+
+class UnknownZoneError(WorkclockError, ValueError):
+    """A time zone name is not in the IANA time zone database."""