flo-python 0.1.0__tar.gz → 0.1.0.dev2__tar.gz

flo_python-0.1.0.dev2/.gitignore

@@ -0,0 +1,142 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+*.manifest
+*.spec
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.log
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+.python-version
+
+# pipenv
+Pipfile.lock
+
+# poetry
+poetry.lock
+
+# pdm
+.pdm.toml
+
+# PEP 582
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# ruff
+.ruff_cache/
+
+# IDE
+.vscode/
+.idea/
+*.swp
+*.swo
+*~
+.DS_Store

flo_python-0.1.0.dev2/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Flo Team
+
+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.

{flo_python-0.1.0 → flo_python-0.1.0.dev2}/PKG-INFO

@@ -1,12 +1,13 @@
 Metadata-Version: 2.4
 Name: flo-python
-Version: 0.1.0
+Version: 0.1.0.dev2
 Summary: Python SDK for the Flo distributed systems platform
 Project-URL: Homepage, https://github.com/floruntime/flo-python
 Project-URL: Documentation, https://github.com/floruntime/flo-python#readme
 Project-URL: Repository, https://github.com/floruntime/flo-python
 Author: Flo Team
 License-Expression: MIT
+License-File: LICENSE
 Keywords: async,distributed-systems,flo,kv-store,queue
 Classifier: Development Status :: 3 - Alpha
 Classifier: Framework :: AsyncIO
@@ -452,39 +453,20 @@ await client.worker.touch(
 
 ```python
 import asyncio
-from flo import FloClient, WorkerAwaitOptions, WorkerFailOptions
+from flo import FloClient
 
 async def run_worker():
-    async with FloClient("localhost:9000") as client:
-        worker_id = "worker-1"
-        task_types = ["process-image"]
-
-        # Register the worker
-        await client.worker.register(worker_id, task_types)
-
-        while True:
-            # Wait for tasks
-            result = await client.worker.await_task(
-                worker_id,
-                task_types,
-                WorkerAwaitOptions(block_ms=30000)
-            )
-
-            if not result.task:
-                continue
-
-            task = result.task
-            try:
-                # Process task
-                output = await process_image(task.input)
-                await client.worker.complete(worker_id, task.task_id, output)
-            except Exception as e:
-                await client.worker.fail(
-                    worker_id,
-                    task.task_id,
-                    str(e),
-                    WorkerFailOptions(retry=True)
-                )
+    async with FloClient("localhost:9000", namespace="myapp") as client:
+        # Create a worker from the client
+        worker = client.new_worker(concurrency=5)
+
+        @worker.action("process-image")
+        async def process_image(ctx):
+            data = ctx.json()
+            result = await do_processing(data)
+            return ctx.to_bytes({"status": "done"})
+
+        await worker.start()
 
 asyncio.run(run_worker())
 ```

{flo_python-0.1.0 → flo_python-0.1.0.dev2}/README.md

@@ -423,39 +423,20 @@ await client.worker.touch(
 
 ```python
 import asyncio
-from flo import FloClient, WorkerAwaitOptions, WorkerFailOptions
+from flo import FloClient
 
 async def run_worker():
-    async with FloClient("localhost:9000") as client:
-        worker_id = "worker-1"
-        task_types = ["process-image"]
-
-        # Register the worker
-        await client.worker.register(worker_id, task_types)
-
-        while True:
-            # Wait for tasks
-            result = await client.worker.await_task(
-                worker_id,
-                task_types,
-                WorkerAwaitOptions(block_ms=30000)
-            )
-
-            if not result.task:
-                continue
-
-            task = result.task
-            try:
-                # Process task
-                output = await process_image(task.input)
-                await client.worker.complete(worker_id, task.task_id, output)
-            except Exception as e:
-                await client.worker.fail(
-                    worker_id,
-                    task.task_id,
-                    str(e),
-                    WorkerFailOptions(retry=True)
-                )
+    async with FloClient("localhost:9000", namespace="myapp") as client:
+        # Create a worker from the client
+        worker = client.new_worker(concurrency=5)
+
+        @worker.action("process-image")
+        async def process_image(ctx):
+            data = ctx.json()
+            result = await do_processing(data)
+            return ctx.to_bytes({"status": "done"})
+
+        await worker.start()
 
 asyncio.run(run_worker())
 ```

{flo_python-0.1.0 → flo_python-0.1.0.dev2}/examples/worker.py

@@ -9,7 +9,7 @@ import os
 import signal
 from dataclasses import dataclass
 
-from flo import ActionContext, Worker
+from flo import ActionContext, FloClient
 
 # Configure logging
 logging.basicConfig(
@@ -158,13 +158,18 @@ async def generate_report(ctx: ActionContext) -> bytes:
 
 
 async def main():
-    # Create worker with configuration
-    worker = Worker(
-        endpoint=os.getenv("FLO_ENDPOINT", "localhost:3000"),
+    # Create and connect client (shared configuration)
+    client = FloClient(
+        os.getenv("FLO_ENDPOINT", "localhost:3000"),
         namespace=os.getenv("FLO_NAMESPACE", "myapp"),
+        debug=os.getenv("FLO_DEBUG", "").lower() in ("1", "true"),
+    )
+    await client.connect()
+
+    # Create a worker from the client
+    worker = client.new_worker(
         concurrency=5,
         action_timeout=300,  # 5 minutes
-        debug=os.getenv("FLO_DEBUG", "").lower() in ("1", "true"),
     )
 
     # Register action handlers using register_action()
@@ -202,6 +207,7 @@ async def main():
         logger.info("Interrupted")
     finally:
         await worker.close()
+        await client.close()
         logger.info("Worker shutdown complete")
 
 

{flo_python-0.1.0 → flo_python-0.1.0.dev2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "flo-python"
-version = "0.1.0"
+version = "0.1.0.dev2"
 description = "Python SDK for the Flo distributed systems platform"
 readme = "README.md"
 license = "MIT"

{flo_python-0.1.0 → flo_python-0.1.0.dev2}/src/flo/__init__.py

@@ -2,23 +2,31 @@
 
 A Python client for the Flo distributed systems platform.
 
+All primitives are accessed as attributes on a connected FloClient:
+
 Example:
     import asyncio
     from flo import FloClient
 
     async def main():
-        async with FloClient("localhost:9000") as client:
+        async with FloClient("localhost:9000", namespace="myapp") as client:
             # KV operations
             await client.kv.put("key", b"value")
             value = await client.kv.get("key")
-            print(f"Got: {value}")
 
             # Queue operations
-            seq = await client.queue.enqueue("tasks", b'{"task": "process"}')
-            result = await client.queue.dequeue("tasks", 10)
-            for msg in result.messages:
-                print(f"Message: {msg.payload}")
-                await client.queue.ack("tasks", [msg.seq])
+            await client.queue.enqueue("tasks", b'{"task": "process"}')
+
+            # Stream operations
+            await client.stream.append("events", b'{"event": "click"}')
+
+            # Action operations
+            await client.action.invoke("process", b'{}')
+
+            # Worker (created from client)
+            worker = client.new_worker(concurrency=5)
+            worker.register_action("my-action", handler)
+            await worker.start()
 
     asyncio.run(main())
 """
@@ -88,6 +96,7 @@ from .types import (
     StreamAppendResult,
     StreamGroupAckOptions,
     StreamGroupJoinOptions,
+    StreamGroupNackOptions,
     StreamGroupReadOptions,
     StreamID,
     StreamInfo,
@@ -111,7 +120,7 @@ from .types import (
     WorkerTask,
     WorkerTouchOptions,
 )
-from .worker import ActionContext, Worker, WorkerConfig
+from .worker import ActionContext, Worker, WorkerOptions
 
 __version__ = "0.1.0"
 
@@ -120,7 +129,7 @@ __all__ = [
     "FloClient",
     # High-level Worker API
     "Worker",
-    "WorkerConfig",
+    "WorkerOptions",
     "ActionContext",
     # Exceptions
     "FloError",
@@ -186,6 +195,7 @@ __all__ = [
     "StreamGroupJoinOptions",
     "StreamGroupReadOptions",
     "StreamGroupAckOptions",
+    "StreamGroupNackOptions",
     # Action types
     "ActionType",
     "ActionInfo",

{flo_python-0.1.0 → flo_python-0.1.0.dev2}/src/flo/client.py

@@ -6,6 +6,7 @@ Async client for connecting to Flo servers.
 import asyncio
 import contextlib
 import logging
+from typing import TYPE_CHECKING
 
 from .exceptions import (
     ConnectionFailedError,
@@ -17,6 +18,9 @@ from .exceptions import (
 from .types import HEADER_SIZE, OpCode, StatusCode
 from .wire import RawResponse, parse_response_header, serialize_request
 
+if TYPE_CHECKING:
+    from .worker import Worker
+
 logger = logging.getLogger("flo")
 
 
@@ -282,3 +286,41 @@ class FloClient:
     def get_namespace(self, override: str | None) -> str:
         """Get effective namespace, using override if provided."""
         return override if override is not None else self._namespace
+
+    def new_worker(
+        self,
+        *,
+        worker_id: str | None = None,
+        concurrency: int = 10,
+        action_timeout: float = 300.0,
+        block_ms: int = 30000,
+    ) -> "Worker":
+        """Create a new Worker from this client.
+
+        The worker inherits the client's endpoint and namespace, and creates
+        a dedicated connection for polling tasks.
+
+        Args:
+            worker_id: Unique worker identifier (auto-generated if not provided).
+            concurrency: Maximum number of concurrent actions.
+            action_timeout: Timeout for action handlers in seconds.
+            block_ms: Timeout for blocking dequeue in milliseconds.
+
+        Returns:
+            A new Worker instance ready to register actions and start.
+
+        Example:
+            async with FloClient("localhost:3000", namespace="myapp") as client:
+                worker = client.new_worker(concurrency=5)
+                worker.register_action("process-order", process_order)
+                await worker.start()
+        """
+        from .worker import Worker
+
+        return Worker(
+            self,
+            worker_id=worker_id,
+            concurrency=concurrency,
+            action_timeout=action_timeout,
+            block_ms=block_ms,
+        )

{flo_python-0.1.0 → flo_python-0.1.0.dev2}/src/flo/streams.py

@@ -13,6 +13,7 @@ from .types import (
     StreamAppendResult,
     StreamGroupAckOptions,
     StreamGroupJoinOptions,
+    StreamGroupNackOptions,
     StreamGroupReadOptions,
     StreamInfo,
     StreamInfoOptions,
@@ -351,14 +352,15 @@ class StreamOperations:
             stream: Stream name.
             group: Consumer group name.
             seqs: Sequence numbers of records to acknowledge.
-            options: Optional ack options.
+            options: Optional ack options (including consumer name).
 
         Example:
             result = await client.stream.group_read("events", "processors", "worker-1")
             for record in result.records:
                 try:
                     process(record.payload)
-                    await client.stream.group_ack("events", "processors", [record.seq])
+                    await client.stream.group_ack("events", "processors", [record.seq],
+                        StreamGroupAckOptions(consumer="worker-1"))
                 except Exception:
                     pass  # Record will be redelivered
         """
@@ -368,7 +370,7 @@ class StreamOperations:
         opts = options or StreamGroupAckOptions()
         namespace = self._client.get_namespace(opts.namespace)
 
-        value = serialize_group_ack_value(group, seqs)
+        value = serialize_group_ack_value(group, seqs, consumer=opts.consumer)
 
         await self._client._send_and_check(
             OpCode.STREAM_GROUP_ACK,
@@ -377,3 +379,48 @@ class StreamOperations:
             value,
             allow_not_found=True,
         )
+
+    async def group_nack(
+        self,
+        stream: str,
+        group: str,
+        seqs: list[int],
+        options: StreamGroupNackOptions | None = None,
+    ) -> None:
+        """Negatively acknowledge records in a consumer group for redelivery.
+
+        Args:
+            stream: Stream name.
+            group: Consumer group name.
+            seqs: Sequence numbers of records to negatively acknowledge.
+            options: Optional nack options (consumer name, redelivery delay).
+
+        Example:
+            result = await client.stream.group_read("events", "processors", "worker-1")
+            for record in result.records:
+                try:
+                    process(record.payload)
+                except Exception:
+                    await client.stream.group_nack("events", "processors", [record.seq],
+                        StreamGroupNackOptions(consumer="worker-1", redelivery_delay_ms=5000))
+        """
+        if not seqs:
+            return
+
+        opts = options or StreamGroupNackOptions()
+        namespace = self._client.get_namespace(opts.namespace)
+
+        value = serialize_group_ack_value(group, seqs, consumer=opts.consumer)
+
+        builder = OptionsBuilder()
+        if opts.redelivery_delay_ms is not None:
+            builder.add_u32(OptionTag.REDELIVERY_DELAY_MS, opts.redelivery_delay_ms)
+
+        await self._client._send_and_check(
+            OpCode.STREAM_GROUP_NACK,
+            namespace,
+            stream.encode("utf-8"),
+            value,
+            builder.build(),
+            allow_not_found=True,
+        )

{flo_python-0.1.0 → flo_python-0.1.0.dev2}/src/flo/types.py

@@ -368,15 +368,15 @@ class StreamID:
     sequence: int = 0
 
     def to_bytes(self) -> bytes:
-        """Serialize the StreamID to 16 bytes (little-endian)."""
-        return struct.pack("<QQ", self.timestamp_ms, self.sequence)
+        """Serialize the StreamID to 16 bytes (big-endian for lexicographic sorting)."""
+        return struct.pack(">QQ", self.timestamp_ms, self.sequence)
 
     @classmethod
     def from_bytes(cls, data: bytes) -> "StreamID":
-        """Parse a StreamID from 16 bytes (little-endian)."""
+        """Parse a StreamID from 16 bytes (big-endian)."""
         if len(data) < 16:
             raise ValueError(f"Invalid StreamID: expected 16 bytes, got {len(data)}")
-        ts, seq = struct.unpack("<QQ", data[:16])
+        ts, seq = struct.unpack(">QQ", data[:16])
         return cls(timestamp_ms=ts, sequence=seq)
 
     @classmethod
@@ -431,6 +431,7 @@ class StreamInfo:
     last_seq: int
     count: int
     bytes_size: int
+    partition_count: int = 1
 
 
 # =============================================================================
@@ -613,6 +614,16 @@ class StreamGroupAckOptions:
     """Options for acknowledging records in a consumer group."""
 
     namespace: str | None = None
+    consumer: str = ""  # Consumer ID (required for correct ack matching)
+
+
+@dataclass
+class StreamGroupNackOptions:
+    """Options for negatively acknowledging records in a consumer group."""
+
+    namespace: str | None = None
+    consumer: str = ""  # Consumer ID (required for correct nack matching)
+    redelivery_delay_ms: int | None = None  # Delay before message becomes visible again
 
 
 # =============================================================================

{flo_python-0.1.0 → flo_python-0.1.0.dev2}/src/flo/wire.py

@@ -633,17 +633,24 @@ def parse_stream_read_response(data: bytes) -> StreamReadResult:
 def parse_stream_info_response(data: bytes) -> StreamInfo:
     """Parse stream info response data.
 
-    Format: [first_seq:u64][last_seq:u64][count:u64][bytes:u64]
+    Format: [first_seq:u64][last_seq:u64][count:u64][bytes:u64][partition_count:u32]
     """
-    if len(data) < 32:
+    if len(data) < 36:
         raise IncompleteResponseError("Stream info response too short")
 
     first_seq = struct.unpack("<Q", data[0:8])[0]
     last_seq = struct.unpack("<Q", data[8:16])[0]
     count = struct.unpack("<Q", data[16:24])[0]
     bytes_size = struct.unpack("<Q", data[24:32])[0]
-
-    return StreamInfo(first_seq=first_seq, last_seq=last_seq, count=count, bytes_size=bytes_size)
+    partition_count = struct.unpack("<I", data[32:36])[0]
+
+    return StreamInfo(
+        first_seq=first_seq,
+        last_seq=last_seq,
+        count=count,
+        bytes_size=bytes_size,
+        partition_count=partition_count,
+    )
 
 
 def serialize_group_value(group: str, consumer: str) -> bytes:
@@ -662,16 +669,19 @@ def serialize_group_value(group: str, consumer: str) -> bytes:
     return bytes(result)
 
 
-def serialize_group_ack_value(group: str, seqs: list[int]) -> bytes:
-    """Serialize group name and sequence numbers for group ack.
+def serialize_group_ack_value(group: str, seqs: list[int], consumer: str = "") -> bytes:
+    """Serialize group name, consumer, and sequence numbers for group ack/nack.
 
-    Format: [group_len:u16][group][count:u32][seq:u64]*
+    Format: [group_len:u16][group][consumer_len:u16][consumer][count:u32][seq:u64]*
     """
     group_bytes = group.encode("utf-8")
+    consumer_bytes = consumer.encode("utf-8")
 
     result = bytearray()
     result.extend(struct.pack("<H", len(group_bytes)))
     result.extend(group_bytes)
+    result.extend(struct.pack("<H", len(consumer_bytes)))
+    result.extend(consumer_bytes)
     result.extend(struct.pack("<I", len(seqs)))
     for seq in seqs:
         result.extend(struct.pack("<Q", seq))

{flo_python-0.1.0 → flo_python-0.1.0.dev2}/src/flo/worker.py

@@ -3,7 +3,7 @@
 Provides an easy-to-use Worker class for executing actions.
 
 Example:
-    from flo import Worker, ActionContext
+    from flo import FloClient, ActionContext
 
     async def process_order(ctx: ActionContext) -> bytes:
         order = ctx.json()
@@ -11,13 +11,10 @@ Example:
         return ctx.to_bytes({"status": "completed"})
 
     async def main():
-        worker = Worker(
-            endpoint="localhost:3000",
-            namespace="myapp",
-        )
-        worker.action("process-order")(process_order)
-
-        await worker.start()
+        async with FloClient("localhost:3000", namespace="myapp") as client:
+            worker = client.new_worker(concurrency=5)
+            worker.action("process-order")(process_order)
+            await worker.start()
 """
 
 import asyncio
@@ -40,16 +37,16 @@ ActionHandler = Callable[["ActionContext"], Awaitable[bytes]]
 
 
 @dataclass
-class WorkerConfig:
-    """Configuration for a Flo worker."""
+class WorkerOptions:
+    """Configuration for a Flo worker.
+
+    Endpoint and namespace are inherited from the parent FloClient.
+    """
 
-    endpoint: str
-    namespace: str = "default"
     worker_id: str = ""
     concurrency: int = 10
     action_timeout: float = 300.0  # 5 minutes
     block_ms: int = 30000
-    debug: bool = False
 
 
 @dataclass
@@ -122,48 +119,44 @@ class ActionContext:
 class Worker:
     """High-level Flo worker for executing actions.
 
+    Created from a FloClient via ``client.new_worker()``.
+
     Example:
-        worker = Worker(endpoint="localhost:3000", namespace="myapp")
+        async with FloClient("localhost:3000", namespace="myapp") as client:
+            worker = client.new_worker(concurrency=5)
 
-        @worker.action("process-order")
-        async def process_order(ctx: ActionContext) -> bytes:
-            order = ctx.json()
-            # Process the order...
-            return ctx.to_bytes({"status": "completed"})
+            @worker.action("process-order")
+            async def process_order(ctx: ActionContext) -> bytes:
+                order = ctx.json()
+                return ctx.to_bytes({"status": "completed"})
 
-        await worker.start()
+            await worker.start()
     """
 
     def __init__(
         self,
-        endpoint: str,
+        parent_client: "FloClient",
         *,
-        namespace: str = "default",
         worker_id: str | None = None,
         concurrency: int = 10,
         action_timeout: float = 300.0,
         block_ms: int = 30000,
-        debug: bool = False,
     ):
-        """Initialize a Flo worker.
+        """Initialize a Flo worker from a connected client.
 
         Args:
-            endpoint: Server endpoint in "host:port" format.
-            namespace: Namespace for operations.
+            parent_client: The parent FloClient whose endpoint and namespace are used.
             worker_id: Unique worker identifier (auto-generated if not provided).
             concurrency: Maximum number of concurrent actions.
             action_timeout: Timeout for action handlers in seconds.
             block_ms: Timeout for blocking dequeue in milliseconds.
-            debug: Enable debug logging.
         """
-        self.config = WorkerConfig(
-            endpoint=endpoint,
-            namespace=namespace,
+        self._parent_client = parent_client
+        self.config = WorkerOptions(
             worker_id=worker_id or self._generate_worker_id(),
             concurrency=concurrency,
             action_timeout=action_timeout,
             block_ms=block_ms,
-            debug=debug,
         )
 
         self._client: FloClient | None = None
@@ -173,9 +166,6 @@ class Worker:
         self._tasks: set[asyncio.Task[None]] = set()
         self._semaphore: asyncio.Semaphore | None = None
 
-        if debug:
-            logging.basicConfig(level=logging.DEBUG)
-
     @staticmethod
     def _generate_worker_id() -> str:
         """Generate a unique worker ID."""
@@ -235,14 +225,14 @@ class Worker:
 
         logger.info(
             f"Starting Flo worker (id={self.config.worker_id}, "
-            f"namespace={self.config.namespace}, concurrency={self.config.concurrency})"
+            f"namespace={self._parent_client.namespace}, concurrency={self.config.concurrency})"
         )
 
-        # Connect to server
+        # Create a dedicated connection using the parent client's endpoint and namespace
         self._client = FloClient(
-            self.config.endpoint,
-            namespace=self.config.namespace,
-            debug=self.config.debug,
+            self._parent_client._endpoint,
+            namespace=self._parent_client.namespace,
+            debug=self._parent_client._debug,
         )
         await self._client.connect()
 
@@ -344,7 +334,7 @@ class Worker:
                 payload=task.payload,
                 attempt=task.attempt,
                 created_at=task.created_at,
-                namespace=self.config.namespace,
+                namespace=self._parent_client.namespace,
                 _worker=self,
             )