ringo-task-queue 0.1.0.dev4__py3-none-win_amd64.whl → 0.1.0.dev6__py3-none-win_amd64.whl

ringo_task_queue/__init__.py

@@ -1,71 +1,71 @@
-"""Asyncio client for Ringo Task Queue."""
-
-from ._version import SDK_VERSION as __version__
-from .client import CompressionOption, LeasedTask, Ringo, RingoClient, TaskQueue
-from .concurrency import AdaptiveConcurrency, ResourceConcurrency
-from .errors import (
-    ConflictError,
-    DeadlineExceededError,
-    DuplicateError,
-    IncompatibleVersionError,
-    InternalError,
-    InvalidArgumentError,
-    LeaseLostError,
-    NotFoundError,
-    PermanentTaskError,
-    RetryTaskError,
-    RingoError,
-    UnavailableError,
-)
-from .models import (
-    Attempt,
-    BatchResult,
-    EnqueueResult,
-    LeaseInfo,
-    PostgresStorage,
-    Progress,
-    RetryPolicy,
-    RetryStrategy,
-    SQLiteStorage,
-    Task,
-    TaskSpec,
-    TaskStatus,
-)
-from .worker import TaskContext, Worker
-
-__all__ = [
-    "AdaptiveConcurrency",
-    "Attempt",
-    "BatchResult",
-    "CompressionOption",
-    "ConflictError",
-    "DeadlineExceededError",
-    "DuplicateError",
-    "EnqueueResult",
-    "IncompatibleVersionError",
-    "InternalError",
-    "InvalidArgumentError",
-    "LeaseInfo",
-    "LeaseLostError",
-    "LeasedTask",
-    "NotFoundError",
-    "PermanentTaskError",
-    "PostgresStorage",
-    "Progress",
-    "ResourceConcurrency",
-    "RetryPolicy",
-    "RetryStrategy",
-    "RetryTaskError",
-    "Ringo",
-    "RingoClient",
-    "RingoError",
-    "SQLiteStorage",
-    "Task",
-    "TaskContext",
-    "TaskQueue",
-    "TaskSpec",
-    "TaskStatus",
-    "UnavailableError",
-    "Worker",
-    "__version__",
-]
+"""Asyncio client for Ringo Task Queue."""
+
+from ._version import SDK_VERSION as __version__
+from .client import CompressionOption, LeasedTask, Ringo, RingoClient, TaskQueue
+from .concurrency import AdaptiveConcurrency, ResourceConcurrency
+from .errors import (
+    ConflictError,
+    DeadlineExceededError,
+    DuplicateError,
+    IncompatibleVersionError,
+    InternalError,
+    InvalidArgumentError,
+    LeaseLostError,
+    NotFoundError,
+    PermanentTaskError,
+    RetryTaskError,
+    RingoError,
+    UnavailableError,
+)
+from .models import (
+    Attempt,
+    BatchResult,
+    EnqueueResult,
+    LeaseInfo,
+    PostgresStorage,
+    Progress,
+    RetryPolicy,
+    RetryStrategy,
+    SQLiteStorage,
+    Task,
+    TaskSpec,
+    TaskStatus,
+)
+from .worker import TaskContext, Worker
+
+__all__ = [
+    "AdaptiveConcurrency",
+    "Attempt",
+    "BatchResult",
+    "CompressionOption",
+    "ConflictError",
+    "DeadlineExceededError",
+    "DuplicateError",
+    "EnqueueResult",
+    "IncompatibleVersionError",
+    "InternalError",
+    "InvalidArgumentError",
+    "LeaseInfo",
+    "LeaseLostError",
+    "LeasedTask",
+    "NotFoundError",
+    "PermanentTaskError",
+    "PostgresStorage",
+    "Progress",
+    "ResourceConcurrency",
+    "RetryPolicy",
+    "RetryStrategy",
+    "RetryTaskError",
+    "Ringo",
+    "RingoClient",
+    "RingoError",
+    "SQLiteStorage",
+    "Task",
+    "TaskContext",
+    "TaskQueue",
+    "TaskSpec",
+    "TaskStatus",
+    "UnavailableError",
+    "Worker",
+    "__version__",
+]

ringo_task_queue/_pb.py

@@ -1,154 +1,154 @@
-"""Conversions between frozen ``ringo.v1`` protobuf messages and Python values.
-
-This module is the single place that knows the wire shapes. It handles:
-
-- arbitrary JSON payloads (including an explicit ``None``) via
-  ``google.protobuf.Value``;
-- timezone-aware UTC ``datetime`` <-> ``google.protobuf.Timestamp``;
-- ``datetime.timedelta`` <-> ``google.protobuf.Duration``.
-"""
-
-from __future__ import annotations
-
-import math
-from datetime import datetime, timedelta, timezone
-from typing import Any
-
-from google.protobuf import duration_pb2, struct_pb2, timestamp_pb2
-
-from .errors import InvalidArgumentError
-
-#: Largest integer exactly representable in a proto ``double``/JSON number.
-_MAX_EXACT_INT = 2**53
-
-# ---------------------------------------------------------------------------
-# JSON values
-
-
-def py_to_value(obj: Any) -> struct_pb2.Value:
-    """Convert an arbitrary JSON-compatible Python value to a proto Value.
-
-    ``None`` becomes an explicit ``null_value`` (the proto contract requires a
-    present payload, and JSON null is legal). Integers beyond the exact range
-    of a proto ``double`` and non-finite floats are rejected instead of being
-    silently corrupted.
-    """
-    msg = struct_pb2.Value()
-    _fill_value(msg, obj)
-    return msg
-
-
-def _fill_value(msg: struct_pb2.Value, obj: Any) -> None:
-    if obj is None:
-        msg.null_value = struct_pb2.NullValue.NULL_VALUE
-    elif isinstance(obj, bool):
-        msg.bool_value = obj
-    elif isinstance(obj, int):
-        if abs(obj) > _MAX_EXACT_INT:
-            raise InvalidArgumentError(
-                f"payload integer {obj} exceeds the exact JSON number range"
-                f" (-2**53..2**53); store it as a string instead"
-            )
-        msg.number_value = float(obj)
-    elif isinstance(obj, float):
-        if not math.isfinite(obj):
-            raise InvalidArgumentError(
-                f"payload contains non-finite float {obj!r}; JSON numbers must be finite"
-            )
-        msg.number_value = obj
-    elif isinstance(obj, str):
-        msg.string_value = obj
-    elif isinstance(obj, (list, tuple)):
-        msg.list_value.SetInParent()
-        for item in obj:
-            _fill_value(msg.list_value.values.add(), item)
-    elif isinstance(obj, dict):
-        msg.struct_value.SetInParent()
-        for key, item in obj.items():
-            if not isinstance(key, str):
-                raise InvalidArgumentError(
-                    f"payload object keys must be strings, got {type(key).__name__}"
-                )
-            _fill_value(msg.struct_value.fields[key], item)
-    else:
-        raise InvalidArgumentError(
-            f"payload value of type {type(obj).__name__} is not JSON-serializable"
-        )
-
-
-def value_to_py(msg: struct_pb2.Value) -> Any:
-    """Convert a proto Value back to plain Python JSON values."""
-    kind = msg.WhichOneof("kind")
-    if kind is None or kind == "null_value":
-        return None
-    if kind == "bool_value":
-        return msg.bool_value
-    if kind == "string_value":
-        return msg.string_value
-    if kind == "number_value":
-        number = msg.number_value
-        # JSON has one numeric type; normalise integral doubles to int so
-        # payloads round-trip through the SDK the way ``json`` users expect.
-        if number.is_integer() and abs(number) <= _MAX_EXACT_INT:
-            return int(number)
-        return number
-    if kind == "list_value":
-        return [value_to_py(v) for v in msg.list_value.values]
-    if kind == "struct_value":
-        return {key: value_to_py(v) for key, v in msg.struct_value.fields.items()}
-    raise InvalidArgumentError(f"unknown Value kind {kind!r}")
-
-
-# ---------------------------------------------------------------------------
-# Time
-
-
-def dt_to_ts(value: datetime) -> timestamp_pb2.Timestamp:
-    if not isinstance(value, datetime):
-        raise InvalidArgumentError(f"expected datetime, got {type(value).__name__}")
-    if value.tzinfo is None:
-        raise InvalidArgumentError(
-            "datetime values must be timezone-aware; use datetime.UTC"
-        )
-    msg = timestamp_pb2.Timestamp()
-    try:
-        msg.FromDatetime(value)
-        # FromDatetime is lenient about seconds; verify round-trip bounds.
-        msg.ToDatetime(tzinfo=timezone.utc)
-    except (ValueError, OverflowError) as exc:
-        raise InvalidArgumentError(f"datetime out of Timestamp range: {exc}") from exc
-    return msg
-
-
-def ts_to_dt(msg: timestamp_pb2.Timestamp) -> datetime:
-    # ToDatetime returns a tz-aware UTC datetime.
-    return msg.ToDatetime(tzinfo=timezone.utc)
-
-
-def td_to_dur(value: timedelta) -> duration_pb2.Duration:
-    if not isinstance(value, timedelta):
-        raise InvalidArgumentError(f"expected timedelta, got {type(value).__name__}")
-    # The daemon/server represents durations as Go time.Duration (int64
-    # nanoseconds, about +/-292 years); reject anything outside that range so
-    # values can never silently wrap.
-    total_ns = (
-        (value.days * 86_400 + value.seconds) * 1_000_000 + value.microseconds
-    ) * 1_000
-    if abs(total_ns) > 2**63 - 1:
-        raise InvalidArgumentError(
-            f"timedelta {value} is outside the representable duration range"
-            " (Go time.Duration, about +/-292 years)"
-        )
-    msg = duration_pb2.Duration()
-    try:
-        msg.FromNanoseconds(total_ns)
-        msg.ToTimedelta()
-    except (ValueError, OverflowError) as exc:
-        raise InvalidArgumentError(f"timedelta out of Duration range: {exc}") from exc
-    return msg
-
-
-def dur_to_td(msg: duration_pb2.Duration | None) -> timedelta | None:
-    if msg is None:
-        return None
-    return msg.ToTimedelta()
+"""Conversions between frozen ``ringo.v1`` protobuf messages and Python values.
+
+This module is the single place that knows the wire shapes. It handles:
+
+- arbitrary JSON payloads (including an explicit ``None``) via
+  ``google.protobuf.Value``;
+- timezone-aware UTC ``datetime`` <-> ``google.protobuf.Timestamp``;
+- ``datetime.timedelta`` <-> ``google.protobuf.Duration``.
+"""
+
+from __future__ import annotations
+
+import math
+from datetime import datetime, timedelta, timezone
+from typing import Any
+
+from google.protobuf import duration_pb2, struct_pb2, timestamp_pb2
+
+from .errors import InvalidArgumentError
+
+#: Largest integer exactly representable in a proto ``double``/JSON number.
+_MAX_EXACT_INT = 2**53
+
+# ---------------------------------------------------------------------------
+# JSON values
+
+
+def py_to_value(obj: Any) -> struct_pb2.Value:
+    """Convert an arbitrary JSON-compatible Python value to a proto Value.
+
+    ``None`` becomes an explicit ``null_value`` (the proto contract requires a
+    present payload, and JSON null is legal). Integers beyond the exact range
+    of a proto ``double`` and non-finite floats are rejected instead of being
+    silently corrupted.
+    """
+    msg = struct_pb2.Value()
+    _fill_value(msg, obj)
+    return msg
+
+
+def _fill_value(msg: struct_pb2.Value, obj: Any) -> None:
+    if obj is None:
+        msg.null_value = struct_pb2.NullValue.NULL_VALUE
+    elif isinstance(obj, bool):
+        msg.bool_value = obj
+    elif isinstance(obj, int):
+        if abs(obj) > _MAX_EXACT_INT:
+            raise InvalidArgumentError(
+                f"payload integer {obj} exceeds the exact JSON number range"
+                f" (-2**53..2**53); store it as a string instead"
+            )
+        msg.number_value = float(obj)
+    elif isinstance(obj, float):
+        if not math.isfinite(obj):
+            raise InvalidArgumentError(
+                f"payload contains non-finite float {obj!r}; JSON numbers must be finite"
+            )
+        msg.number_value = obj
+    elif isinstance(obj, str):
+        msg.string_value = obj
+    elif isinstance(obj, (list, tuple)):
+        msg.list_value.SetInParent()
+        for item in obj:
+            _fill_value(msg.list_value.values.add(), item)
+    elif isinstance(obj, dict):
+        msg.struct_value.SetInParent()
+        for key, item in obj.items():
+            if not isinstance(key, str):
+                raise InvalidArgumentError(
+                    f"payload object keys must be strings, got {type(key).__name__}"
+                )
+            _fill_value(msg.struct_value.fields[key], item)
+    else:
+        raise InvalidArgumentError(
+            f"payload value of type {type(obj).__name__} is not JSON-serializable"
+        )
+
+
+def value_to_py(msg: struct_pb2.Value) -> Any:
+    """Convert a proto Value back to plain Python JSON values."""
+    kind = msg.WhichOneof("kind")
+    if kind is None or kind == "null_value":
+        return None
+    if kind == "bool_value":
+        return msg.bool_value
+    if kind == "string_value":
+        return msg.string_value
+    if kind == "number_value":
+        number = msg.number_value
+        # JSON has one numeric type; normalise integral doubles to int so
+        # payloads round-trip through the SDK the way ``json`` users expect.
+        if number.is_integer() and abs(number) <= _MAX_EXACT_INT:
+            return int(number)
+        return number
+    if kind == "list_value":
+        return [value_to_py(v) for v in msg.list_value.values]
+    if kind == "struct_value":
+        return {key: value_to_py(v) for key, v in msg.struct_value.fields.items()}
+    raise InvalidArgumentError(f"unknown Value kind {kind!r}")
+
+
+# ---------------------------------------------------------------------------
+# Time
+
+
+def dt_to_ts(value: datetime) -> timestamp_pb2.Timestamp:
+    if not isinstance(value, datetime):
+        raise InvalidArgumentError(f"expected datetime, got {type(value).__name__}")
+    if value.tzinfo is None:
+        raise InvalidArgumentError(
+            "datetime values must be timezone-aware; use datetime.UTC"
+        )
+    msg = timestamp_pb2.Timestamp()
+    try:
+        msg.FromDatetime(value)
+        # FromDatetime is lenient about seconds; verify round-trip bounds.
+        msg.ToDatetime(tzinfo=timezone.utc)
+    except (ValueError, OverflowError) as exc:
+        raise InvalidArgumentError(f"datetime out of Timestamp range: {exc}") from exc
+    return msg
+
+
+def ts_to_dt(msg: timestamp_pb2.Timestamp) -> datetime:
+    # ToDatetime returns a tz-aware UTC datetime.
+    return msg.ToDatetime(tzinfo=timezone.utc)
+
+
+def td_to_dur(value: timedelta) -> duration_pb2.Duration:
+    if not isinstance(value, timedelta):
+        raise InvalidArgumentError(f"expected timedelta, got {type(value).__name__}")
+    # The daemon/server represents durations as Go time.Duration (int64
+    # nanoseconds, about +/-292 years); reject anything outside that range so
+    # values can never silently wrap.
+    total_ns = (
+        (value.days * 86_400 + value.seconds) * 1_000_000 + value.microseconds
+    ) * 1_000
+    if abs(total_ns) > 2**63 - 1:
+        raise InvalidArgumentError(
+            f"timedelta {value} is outside the representable duration range"
+            " (Go time.Duration, about +/-292 years)"
+        )
+    msg = duration_pb2.Duration()
+    try:
+        msg.FromNanoseconds(total_ns)
+        msg.ToTimedelta()
+    except (ValueError, OverflowError) as exc:
+        raise InvalidArgumentError(f"timedelta out of Duration range: {exc}") from exc
+    return msg
+
+
+def dur_to_td(msg: duration_pb2.Duration | None) -> timedelta | None:
+    if msg is None:
+        return None
+    return msg.ToTimedelta()