gisolate 0.2.14__tar.gz → 0.2.16.dev0__tar.gz

gisolate-0.2.16.dev0/.code-review-graph/.gitignore

@@ -0,0 +1,3 @@
+# Auto-generated by code-review-graph — do not commit database files.
+# The graph.db contains absolute paths and code structure metadata.
+*

{gisolate-0.2.14 → gisolate-0.2.16.dev0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: gisolate
-Version: 0.2.14
+Version: 0.2.16.dev0
 Summary: Process isolation for gevent applications — run any object in a clean subprocess, call methods transparently via ZMQ IPC.
 Project-URL: Repository, https://github.com/wy-z/gisolate
 License-Expression: MIT
@@ -105,6 +105,47 @@ asyncio.run(main())
 server.close()
 ```
 
+### ProcessPublisher / ProcessSubscriber — one-way fan-out
+
+ZMQ PUB/SUB for one-way data streaming (snapshots, signals, heartbeats). Use this when message loss is acceptable; use `ProcessBridge` when you need request/response with delivery guarantees.
+
+```python
+# Producer (gevent side)
+from gisolate import ProcessPublisher
+
+pub = ProcessPublisher("ipc:///tmp/stream.sock").start()
+pub.publish("v1.snapshot.AAPL", {"price": 150.0})
+pub.publish("v1.heartbeat.gevent", {"ts_ns": 1234567890})
+pub.close()
+
+# Consumer (asyncio side)
+import asyncio
+from gisolate import ProcessSubscriber
+
+async def main():
+    sub = ProcessSubscriber("ipc:///tmp/stream.sock")
+
+    async def on_snapshot(topic, payload):
+        print(topic, payload)
+
+    async def on_heartbeat(topic, payload):
+        print("heartbeat", payload)
+
+    sub.subscribe("v1.snapshot.", on_snapshot)
+    sub.subscribe("v1.heartbeat.", on_heartbeat)
+    sub.start()
+    await asyncio.sleep(10)
+    await sub.close()
+
+asyncio.run(main())
+```
+
+Notes:
+- **Topic prefix matching** — `sub.subscribe("v1.snapshot.", h)` receives every topic starting with that prefix.
+- **Multiple handlers per prefix** — invoked concurrently with `asyncio.gather`. Exceptions in one handler do not kill the reader task.
+- **Lossy by design** — `publish` is non-blocking; messages are dropped when the send queue is full (slow subscriber). Set `sndhwm=` to tune.
+- **Pluggable serializer** — defaults to `SmartPickle`. Pass any object implementing the `Serializer` protocol (`dumps`/`loads`) to use msgpack, JSON, etc.
+
 ### ThreadLocalProxy — per-thread instances
 
 Thread-local proxy using unpatched `threading.local` for true isolation in `gevent.threadpool`:
@@ -153,6 +194,25 @@ Run a function in an isolated subprocess. Blocks with gevent-safe polling.
 - **`await bridge.call(func, *args, timeout=60, **kwargs)`** — async RPC call (client mode)
 - **`bridge.close()`** — cleanup resources
 
+### `ProcessPublisher(address, *, serializer=SmartPickle, sndhwm=1000)`
+
+- **`pub.start()`** — bind the PUB socket (idempotent, returns self)
+- **`pub.publish(topic, payload)`** — non-blocking publish; drops on slow consumers
+- **`pub.close()`** — cleanup (idempotent)
+- Supports context manager (`with` statement)
+
+### `ProcessSubscriber(address, *, serializer=SmartPickle)`
+
+- **`sub.subscribe(topic_prefix, handler)`** — register an async handler for a topic prefix
+- **`sub.unsubscribe(topic_prefix, handler=None)`** — remove a handler or all handlers for a prefix
+- **`sub.start()`** — connect and spawn the reader task (idempotent, returns self)
+- **`await sub.close()`** — cancel reader and cleanup (idempotent)
+- Supports async context manager (`async with` statement)
+
+### `Serializer` (Protocol)
+
+Anything with `dumps(obj) -> bytes` and `loads(bytes) -> obj` static methods can be used as a serializer for `ProcessPublisher` / `ProcessSubscriber`. Default is `SmartPickle` (pickle, falling back to dill).
+
 ### `ThreadLocalProxy(factory)`
 
 Transparent proxy delegating attribute access to a per-thread instance.

{gisolate-0.2.14 → gisolate-0.2.16.dev0}/README.md

@@ -84,6 +84,47 @@ asyncio.run(main())
 server.close()
 ```
 
+### ProcessPublisher / ProcessSubscriber — one-way fan-out
+
+ZMQ PUB/SUB for one-way data streaming (snapshots, signals, heartbeats). Use this when message loss is acceptable; use `ProcessBridge` when you need request/response with delivery guarantees.
+
+```python
+# Producer (gevent side)
+from gisolate import ProcessPublisher
+
+pub = ProcessPublisher("ipc:///tmp/stream.sock").start()
+pub.publish("v1.snapshot.AAPL", {"price": 150.0})
+pub.publish("v1.heartbeat.gevent", {"ts_ns": 1234567890})
+pub.close()
+
+# Consumer (asyncio side)
+import asyncio
+from gisolate import ProcessSubscriber
+
+async def main():
+    sub = ProcessSubscriber("ipc:///tmp/stream.sock")
+
+    async def on_snapshot(topic, payload):
+        print(topic, payload)
+
+    async def on_heartbeat(topic, payload):
+        print("heartbeat", payload)
+
+    sub.subscribe("v1.snapshot.", on_snapshot)
+    sub.subscribe("v1.heartbeat.", on_heartbeat)
+    sub.start()
+    await asyncio.sleep(10)
+    await sub.close()
+
+asyncio.run(main())
+```
+
+Notes:
+- **Topic prefix matching** — `sub.subscribe("v1.snapshot.", h)` receives every topic starting with that prefix.
+- **Multiple handlers per prefix** — invoked concurrently with `asyncio.gather`. Exceptions in one handler do not kill the reader task.
+- **Lossy by design** — `publish` is non-blocking; messages are dropped when the send queue is full (slow subscriber). Set `sndhwm=` to tune.
+- **Pluggable serializer** — defaults to `SmartPickle`. Pass any object implementing the `Serializer` protocol (`dumps`/`loads`) to use msgpack, JSON, etc.
+
 ### ThreadLocalProxy — per-thread instances
 
 Thread-local proxy using unpatched `threading.local` for true isolation in `gevent.threadpool`:
@@ -132,6 +173,25 @@ Run a function in an isolated subprocess. Blocks with gevent-safe polling.
 - **`await bridge.call(func, *args, timeout=60, **kwargs)`** — async RPC call (client mode)
 - **`bridge.close()`** — cleanup resources
 
+### `ProcessPublisher(address, *, serializer=SmartPickle, sndhwm=1000)`
+
+- **`pub.start()`** — bind the PUB socket (idempotent, returns self)
+- **`pub.publish(topic, payload)`** — non-blocking publish; drops on slow consumers
+- **`pub.close()`** — cleanup (idempotent)
+- Supports context manager (`with` statement)
+
+### `ProcessSubscriber(address, *, serializer=SmartPickle)`
+
+- **`sub.subscribe(topic_prefix, handler)`** — register an async handler for a topic prefix
+- **`sub.unsubscribe(topic_prefix, handler=None)`** — remove a handler or all handlers for a prefix
+- **`sub.start()`** — connect and spawn the reader task (idempotent, returns self)
+- **`await sub.close()`** — cancel reader and cleanup (idempotent)
+- Supports async context manager (`async with` statement)
+
+### `Serializer` (Protocol)
+
+Anything with `dumps(obj) -> bytes` and `loads(bytes) -> obj` static methods can be used as a serializer for `ProcessPublisher` / `ProcessSubscriber`. Default is `SmartPickle` (pickle, falling back to dill).
+
 ### `ThreadLocalProxy(factory)`
 
 Transparent proxy delegating attribute access to a per-thread instance.

{gisolate-0.2.14 → gisolate-0.2.16.dev0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "gisolate"
-version = "0.2.14"
+version = "0.2.16.dev0"
 description = "Process isolation for gevent applications — run any object in a clean subprocess, call methods transparently via ZMQ IPC."
 readme = "README.md"
 license = "MIT"

{gisolate-0.2.14 → gisolate-0.2.16.dev0}/src/gisolate/__init__.py

@@ -4,11 +4,12 @@ Run any object in a clean subprocess, call methods transparently via ZMQ IPC.
 Isolates libraries incompatible with gevent monkey-patching.
 """
 
-from ._internal import ProcessError, RemoteError
+from ._internal import ProcessError, RemoteError, Serializer
 from .bridge import ProcessBridge
 from .hub import ensure_hub_started, shutdown as shutdown_hub, spawn_on_main_hub
 from .local import ThreadLocalProxy
 from .proxy import ProcessProxy, get_default_mp_context, set_default_mp_context
+from .pubsub import ProcessPublisher, ProcessSubscriber
 from .subprocess import run_in_subprocess
 
 # Pre-initialize threadpoolctl on main thread to cache library info.
@@ -24,7 +25,10 @@ __all__ = [
     "ProcessBridge",
     "ProcessError",
     "ProcessProxy",
+    "ProcessPublisher",
+    "ProcessSubscriber",
     "RemoteError",
+    "Serializer",
     "ThreadLocalProxy",
     "ensure_hub_started",
     "get_default_mp_context",

{gisolate-0.2.14 → gisolate-0.2.16.dev0}/src/gisolate/_internal.py

@@ -4,7 +4,7 @@ import contextlib
 import io
 import logging
 import pickle
-from typing import Any
+from typing import Any, Protocol, runtime_checkable
 
 import dill
 import gevent.monkey
@@ -44,8 +44,22 @@ class RemoteError(RuntimeError):
 # ---------------------------------------------------------------------------
 
 
+@runtime_checkable
+class Serializer(Protocol):
+    """Pluggable serializer protocol: ``dumps(obj) -> bytes`` / ``loads(bytes) -> obj``."""
+
+    @staticmethod
+    def dumps(obj: Any) -> bytes: ...
+
+    @staticmethod
+    def loads(data: bytes) -> Any: ...
+
+
 class SmartPickle:
-    """Serializer preferring pickle, falling back to dill. Learns from failures."""
+    """Serializer preferring pickle, falling back to dill. Learns from failures.
+
+    Implements the :class:`Serializer` protocol.
+    """
 
     _PICKLE = b"P"
     _DILL = b"D"

{gisolate-0.2.14 → gisolate-0.2.16.dev0}/src/gisolate/proxy.py

@@ -73,14 +73,14 @@ class ProcessProxy(abc.ABC):
         - shutdown(): thread-safe (marshals to main hub if needed)
     """
 
-    AUTO_RESTART_THRESHOLD = 6
-    RESTART_COOLDOWN = 6.0
-    ALIVE_CHECK_INTERVAL = 10
     mp_context: Any = None
     patch_kwargs: dict | None = None
     timeout: float = 24
     max_concurrency: int | None = None
     daemon: bool = True
+    auto_restart_threshold: int = 6
+    restart_cooldown: float = 6.0
+    alive_check_interval: int = 10
 
     @staticmethod
     @abc.abstractmethod
@@ -215,7 +215,7 @@ class ProcessProxy(abc.ABC):
             return hub.run_on_main_hub(self.restart_process)
         with self._lock:
             now = time.monotonic()
-            if self._is_alive() and now - self._last_restart < self.RESTART_COOLDOWN:
+            if self._is_alive() and now - self._last_restart < self.restart_cooldown:
                 log.warning("Restart skipped (cooldown)")
                 return
             self._last_restart = now
@@ -260,7 +260,7 @@ class ProcessProxy(abc.ABC):
                     idle_cycles = 0
                 else:
                     idle_cycles += 1
-                if idle_cycles >= self.ALIVE_CHECK_INTERVAL and not self._is_alive():
+                if idle_cycles >= self.alive_check_interval and not self._is_alive():
                     break
             if not self._shutdown:
                 log.warning("Child process died, stopping reader")
@@ -334,7 +334,7 @@ class ProcessProxy(abc.ABC):
         except ProcessError:
             with self._lock:
                 self._error_count += 1
-                should_restart = self._error_count >= self.AUTO_RESTART_THRESHOLD
+                should_restart = self._error_count >= self.auto_restart_threshold
             if should_restart:
                 log.warning(f"{self._error_count} consecutive errors, restarting")
                 self.restart_process()