repid 2.1.0__tar.gz → 2.1.2__tar.gz

{repid-2.1.0 → repid-2.1.2}/.pre-commit-config.yaml

@@ -19,7 +19,7 @@ repos:
   - id: end-of-file-fixer
 
 - repo: https://github.com/astral-sh/ruff-pre-commit
-  rev: v0.15.12
+  rev: v0.15.15
   hooks:
   - id: ruff-check
     args: [--fix, --exit-non-zero-on-fix]

{repid-2.1.0 → repid-2.1.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: repid
-Version: 2.1.0
+Version: 2.1.2
 Summary: Repid is a simple, fast, and extensible async task queue framework, with built-in AsyncAPI 3.0 schema generation.
 Project-URL: documentation, https://repid.aleksul.space
 Project-URL: funding, https://github.com/sponsors/aleksul

{repid-2.1.0 → repid-2.1.2}/docs/index.md

@@ -65,33 +65,47 @@ if __name__ == "__main__":
 
 ## Install
 
-**Repid** supports Python versions 3.10 and up and is installable via `pip`.
+**Repid** supports Python 3.10 and later. Install it with `pip`:
 
 ```bash
 pip install repid
 ```
 
-There are also a couple of additional dependencies you may want to install,
-depending on your use case:
+Or with `uv`:
 
 ```bash
-pip install repid[amqp, redis, pubsub, pydantic]
+uv add repid
+```
+
+Install extras for the integrations you use:
+
+- `pydantic` - Pydantic deserialization support
+- `amqp` - AMQP 1.0 broker support
+- `nats` - NATS broker support
+- `redis` - Redis broker support
+- `pubsub` - GCP Pub/Sub broker support
+- `kafka` - Apache Kafka broker support
+- `sqs` - Amazon SQS broker support
+
+```bash
+pip install "repid[pydantic,amqp,nats,redis,pubsub,kafka,sqs]"
 ```
 
 ## Why Repid?
 
-**Repid** brings modern Python developer experience (DX) to background tasks, moving away from
-legacy patterns and embracing strong typing, clear architecture, and flexibility.
-
-- 📖 **AsyncAPI Native**: Stop maintaining outdated architecture diagrams. Repid automatically
-  inspects your actors and generates AsyncAPI 3.0 schemas and interactive web documentation.
-- 🛡️ **Modern Typing & Validation**: First-class Pydantic support. Your message payloads and headers
-  are strictly validated and type-coerced before your actors even run.
-- 💉 **Dependency Injection**: Write clean, testable code. Inject database connections, settings, or
-  shared logic directly into your actor signatures.
-- 🔌 **Highly Unopinionated**: Repid doesn't force a strict ecosystem. You can use it as just a
-  producer, just a consumer, or easily swap out underlying message brokers without rewriting your
-  business logic.
+**Repid** gives async Python applications a clean task queue API with type hints, schema generation,
+and broker flexibility built in.
+
+- **AsyncAPI native**: Repid inspects your actors and generates AsyncAPI 3.0 schemas with interactive
+  web documentation, so your task contracts stay close to the code that handles them.
+- **Typed message handling**: With the `pydantic`, Repid can deserialize, validate, and coerce
+  message payloads and headers before an actor runs.
+- **Async-first performance**: Repid keeps the worker path small and async-native, avoiding sync
+  compatibility layers around broker I/O and actor execution.
+- **Dependency injection**: Actors can receive database connections, settings, clients, or other shared
+  objects directly through their function signatures, keeping task code easier to test and reuse.
+- **Broker flexibility**: Use Repid as a producer, a consumer, or both. Broker implementations sit
+  behind the same application API, so business logic stays separate from transport code.
 
 ## LLMs
 

{repid-2.1.0 → repid-2.1.2}/repid/connections/amqp/_uamqp/_decode.py

@@ -6,9 +6,12 @@ from collections.abc import Callable
 from dataclasses import fields
 from typing import Any, Literal, TypeVar
 
-from . import performatives
+from . import endpoints, outcomes, performatives
 from .message import Header, Message, Properties
 
+FRAME_HEADER_SIZE = 8
+MIN_DOFF = 2
+
 # Maps fixed-width constructor bytes to the number of data bytes to skip.
 # Used to advance past the descriptor in a described type without allocating a Python object.
 _DESCRIPTOR_SKIP_SIZES: dict[int, int] = {
@@ -134,6 +137,22 @@ def _decode_timestamp(buffer: memoryview) -> tuple[memoryview, int]:
     return buffer[8:], c_signed_long_long.unpack(buffer[:8])[0]
 
 
+def _decode_char(buffer: memoryview) -> tuple[memoryview, str]:
+    return buffer[4:], chr(c_unsigned_int.unpack(buffer[:4])[0])
+
+
+def _decode_decimal32(buffer: memoryview) -> tuple[memoryview, bytes]:
+    return buffer[4:], buffer[:4].tobytes()
+
+
+def _decode_decimal64(buffer: memoryview) -> tuple[memoryview, bytes]:
+    return buffer[8:], buffer[:8].tobytes()
+
+
+def _decode_decimal128(buffer: memoryview) -> tuple[memoryview, bytes]:
+    return buffer[16:], buffer[:16].tobytes()
+
+
 def _decode_uuid(buffer: memoryview) -> tuple[memoryview, uuid.UUID]:
     return buffer[16:], uuid.UUID(bytes=buffer[:16].tobytes())
 
@@ -191,37 +210,53 @@ def _decode_map_large(buffer: memoryview) -> tuple[memoryview, dict[Any, Any]]:
 def _decode_array_small(buffer: memoryview) -> tuple[memoryview, list[Any]]:
     count = buffer[1]  # Ignore first byte (size) and just rely on count
     if count:
-        subconstructor = buffer[2]
-        buffer = buffer[3:]
-        values = [None] * count
-        for i in range(count):
-            buffer, values[i] = _DECODE_MAP[subconstructor](buffer)
-        return buffer, values
+        return _decode_array_values(buffer[2], buffer[3:], count)
     return buffer[2:], []
 
 
 def _decode_array_large(buffer: memoryview) -> tuple[memoryview, list[Any]]:
     count = c_unsigned_long.unpack(buffer[4:8])[0]
     if count:
-        subconstructor = buffer[8]
-        buffer = buffer[9:]
-        values = [None] * count
-        for i in range(count):
-            buffer, values[i] = _DECODE_MAP[subconstructor](buffer)
-        return buffer, values
+        return _decode_array_values(buffer[8], buffer[9:], count)
     return buffer[8:], []
 
 
+def _decode_array_values(
+    subconstructor: int,
+    buffer: memoryview,
+    count: int,
+) -> tuple[memoryview, list[Any]]:
+    descriptor: Any | None = None
+    if subconstructor == 0x00:
+        descriptor_constructor = buffer[0]
+        buffer, descriptor = _DECODE_MAP[descriptor_constructor](buffer[1:])
+        subconstructor = buffer[0]
+        buffer = buffer[1:]
+
+    values = [None] * count
+    decoder = _DECODE_MAP[subconstructor]
+    for i in range(count):
+        buffer, value = decoder(buffer)
+        if descriptor is not None:
+            value = _construct_described_value(descriptor, value)
+        values[i] = value
+    return buffer, values
+
+
 def _decode_described(buffer: memoryview) -> tuple[memoryview, object]:
     constructor = buffer[0]
-    skip = _DESCRIPTOR_SKIP_SIZES.get(constructor)
-    if skip is not None:
-        buffer = buffer[1 + skip :]
-    else:
-        # Variable-length or nested described type: decode and discard the descriptor.
-        buffer, _ = _DECODE_MAP[constructor](buffer[1:])
-    result: tuple[memoryview, object] = _DECODE_MAP[buffer[0]](buffer[1:])
-    return result
+    buffer, descriptor = _DECODE_MAP[constructor](buffer[1:])
+    buffer, value = _DECODE_MAP[buffer[0]](buffer[1:])
+    return buffer, _construct_described_value(descriptor, value)
+
+
+def _construct_described_value(descriptor: Any, value: Any) -> object:
+    cls = DESCRIBED_TYPES_MAP.get(descriptor)
+    if cls is None:
+        return (descriptor, value)
+    if isinstance(value, list):
+        return _list_to_dataclass(cls, value)
+    return value
 
 
 def _decode_string_small(buffer: memoryview) -> tuple[memoryview, str]:
@@ -268,10 +303,14 @@ _DECODE_MAP: dict[int, Callable] = {
     0x00000070: _decode_uint_large,
     0x00000071: _decode_int_large,
     0x00000072: _decode_float,
+    0x00000073: _decode_char,
+    0x00000074: _decode_decimal32,
     0x00000080: _decode_ulong_large,
     0x00000081: _decode_long_large,
     0x00000082: _decode_double,
     0x00000083: _decode_timestamp,
+    0x00000084: _decode_decimal64,
+    0x00000094: _decode_decimal128,
     0x00000098: _decode_uuid,
     0x000000A0: _decode_binary_small,
     0x000000A1: _decode_string_small,
@@ -290,6 +329,18 @@ _DECODE_MAP: dict[int, Callable] = {
 ListToDataclassT = TypeVar("ListToDataclassT")
 
 
+DESCRIBED_TYPES_MAP: dict[int, type[Any]] = {
+    performatives.Error.CODE: performatives.Error,
+    endpoints.Source.CODE: endpoints.Source,
+    endpoints.Target.CODE: endpoints.Target,
+    outcomes.Received.CODE: outcomes.Received,
+    outcomes.Accepted.CODE: outcomes.Accepted,
+    outcomes.Rejected.CODE: outcomes.Rejected,
+    outcomes.Released.CODE: outcomes.Released,
+    outcomes.Modified.CODE: outcomes.Modified,
+}
+
+
 def _list_to_dataclass(cls: type[ListToDataclassT], fields_list: list[Any]) -> ListToDataclassT:
     kwargs = {}
     cls_fields = fields(cls)  # type: ignore[arg-type]
@@ -311,7 +362,13 @@ def bytes_to_performative(data: bytes) -> performatives.Performative:
     # channel = struct.unpack(">H", buffer[6:8])[0]
 
     # Body
+    if size < FRAME_HEADER_SIZE:
+        raise ValueError(f"Invalid frame size: {size}")
+    if doff < MIN_DOFF:
+        raise ValueError(f"Invalid frame data offset: {doff}")
     body_start = doff * 4
+    if size < body_start:
+        raise ValueError(f"Frame size {size} smaller than data offset {body_start}")
     body_buffer = buffer[body_start:size]
 
     if len(body_buffer) == 0:
@@ -395,9 +452,13 @@ def _construct_message(payload: bytes) -> Message:  # noqa: C901, PLR0912
         elif descriptor == 0x00000074:  # Application Properties  # noqa: PLR2004
             message.application_properties = value
         elif descriptor == 0x00000075:  # Data  # noqa: PLR2004
-            message.data = value
+            if message.data is None:
+                message.data = []
+            message.data.append(value)
         elif descriptor == 0x00000076:  # Sequence  # noqa: PLR2004
-            message.sequence = value
+            if message.sequence is None:
+                message.sequence = []
+            message.sequence.append(value)
         elif descriptor == 0x00000077:  # Value  # noqa: PLR2004
             message.value = value
         elif descriptor == 0x00000078:  # Footer  # noqa: PLR2004
@@ -411,7 +472,7 @@ def transfer_frames_to_message(frames: list[performatives.TransferFrame]) -> Mes
     for frame in frames:
         if frame.payload:
             payload.extend(frame.payload)
-    return _construct_message(payload)
+    return _construct_message(bytes(payload))
 
 
 def decode_frame(data: bytes) -> tuple[int, performatives.Performative]: