uhttp-workers 1.4.0__tar.gz → 1.5.0__tar.gz

{uhttp_workers-1.4.0 → uhttp_workers-1.5.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: uhttp-workers
-Version: 1.4.0
+Version: 1.5.0
 Summary: Multi-process worker dispatcher built on uhttp-server
 Author-email: Pavel Revak <pavelrevak@gmail.com>
 License-Expression: MIT
@@ -10,7 +10,7 @@ Classifier: Programming Language :: Python :: 3
 Classifier: Operating System :: POSIX
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown
-Requires-Dist: uhttp-server
+Requires-Dist: uhttp-server>=2.5.2
 
 # uhttp-workers
 
@@ -384,6 +384,31 @@ Available streaming methods on `Request`:
 
 Streaming requests are excluded from dispatcher timeout expiration. When the client disconnects, the dispatcher notifies the worker via `on_disconnect(request_id)`.
 
+### NDJSON Streaming
+
+Stream JSON objects line-by-line (`application/x-ndjson`) — one JSON value per line, terminated by `\n`. Useful for incremental APIs that aren't event-shaped (long lists, log tails, progress updates):
+
+```python
+class MyWorker(_workers.Worker):
+    @_workers.api('/devices/scan', 'GET')
+    def scan(self, request):
+        request.response_ndjson()
+        for device in self.discover_devices():
+            request.send_ndjson({'id': device.id, 'name': device.name})
+        request.response_stream_end()
+        return _workers.DEFERRED
+```
+
+NDJSON methods on `Request`:
+
+| Method | Description |
+|--------|-------------|
+| `response_ndjson(headers, cookies)` | Start NDJSON stream (wrapper over `response_stream` with `application/x-ndjson`) |
+| `send_ndjson(obj)` | Send one JSON-serializable value as a line |
+| `response_stream_end()` | End stream and close connection (shared with SSE) |
+
+Same lifecycle as SSE: excluded from timeout expiration, client disconnect triggers `on_disconnect(request_id)`.
+
 ### Flow Control
 
 Workers can stop accepting new requests when busy. Requests stay in the shared pool queue for other workers to pick up:

uhttp_workers-1.4.0/uhttp_workers.egg-info/PKG-INFO → uhttp_workers-1.5.0/README.md

@@ -1,17 +1,3 @@
-Metadata-Version: 2.4
-Name: uhttp-workers
-Version: 1.4.0
-Summary: Multi-process worker dispatcher built on uhttp-server
-Author-email: Pavel Revak <pavelrevak@gmail.com>
-License-Expression: MIT
-Project-URL: Homepage, https://github.com/pavelrevak/uhttp
-Project-URL: Repository, https://github.com/pavelrevak/uhttp
-Classifier: Programming Language :: Python :: 3
-Classifier: Operating System :: POSIX
-Requires-Python: >=3.10
-Description-Content-Type: text/markdown
-Requires-Dist: uhttp-server
-
 # uhttp-workers
 
 Multi-process worker dispatcher built on [uhttp-server](https://github.com/cortexm/uhttp-server).
@@ -384,6 +370,31 @@ Available streaming methods on `Request`:
 
 Streaming requests are excluded from dispatcher timeout expiration. When the client disconnects, the dispatcher notifies the worker via `on_disconnect(request_id)`.
 
+### NDJSON Streaming
+
+Stream JSON objects line-by-line (`application/x-ndjson`) — one JSON value per line, terminated by `\n`. Useful for incremental APIs that aren't event-shaped (long lists, log tails, progress updates):
+
+```python
+class MyWorker(_workers.Worker):
+    @_workers.api('/devices/scan', 'GET')
+    def scan(self, request):
+        request.response_ndjson()
+        for device in self.discover_devices():
+            request.send_ndjson({'id': device.id, 'name': device.name})
+        request.response_stream_end()
+        return _workers.DEFERRED
+```
+
+NDJSON methods on `Request`:
+
+| Method | Description |
+|--------|-------------|
+| `response_ndjson(headers, cookies)` | Start NDJSON stream (wrapper over `response_stream` with `application/x-ndjson`) |
+| `send_ndjson(obj)` | Send one JSON-serializable value as a line |
+| `response_stream_end()` | End stream and close connection (shared with SSE) |
+
+Same lifecycle as SSE: excluded from timeout expiration, client disconnect triggers `on_disconnect(request_id)`.
+
 ### Flow Control
 
 Workers can stop accepting new requests when busy. Requests stay in the shared pool queue for other workers to pick up:

{uhttp_workers-1.4.0 → uhttp_workers-1.5.0}/pyproject.toml

@@ -13,7 +13,7 @@ authors = [
 license = "MIT"
 requires-python = ">=3.10"
 dependencies = [
-    "uhttp-server",
+    "uhttp-server>=2.5.2",
 ]
 classifiers = [
     "Programming Language :: Python :: 3",

{uhttp_workers-1.4.0 → uhttp_workers-1.5.0}/tests/test_dispatcher.py

@@ -10,7 +10,7 @@ from uhttp.workers import (
     Dispatcher, Worker, WorkerPool, Request, Response,
     api, sync, RejectRequest,
     MSG_RESPONSE, MSG_HEARTBEAT,
-    MSG_SSE_OPEN, MSG_SSE_EVENT, MSG_SSE_CLOSE,
+    MSG_SSE_OPEN, MSG_SSE_EVENT, MSG_SSE_CLOSE, MSG_NDJSON,
     CTL_DISCONNECT,
     PENDING_COMPLETED, PENDING_TIMEOUT, PENDING_DISCONNECTED,
     PENDING_STREAM_CLOSED, PENDING_SHUTDOWN,
@@ -78,6 +78,12 @@ class MockClient:
         self._chunks.append(data)
         return getattr(self, '_connected', True)
 
+    def send_ndjson(self, obj):
+        if not hasattr(self, '_ndjson'):
+            self._ndjson = []
+        self._ndjson.append(obj)
+        return getattr(self, '_connected', True)
+
     def response_stream_end(self):
         self.stream_ended = True
 
@@ -547,6 +553,42 @@ class TestDispatcherSSE(unittest.TestCase):
         # non-streaming should be expired
         self.assertNotIn(1, d._pending)
 
+    def test_ndjson_send(self):
+        d, pool = self._make_dispatcher()
+        client = MockClient('GET', '/api/stream')
+        pending = _PendingRequest(client, pool)
+        pending.streaming = True
+        d._pending[1] = pending
+        d._process_response(
+            (MSG_NDJSON, 1, {'devices': [1, 2, 3]}))
+        self.assertEqual(len(client._ndjson), 1)
+        self.assertEqual(client._ndjson[0], {'devices': [1, 2, 3]})
+        # still pending — stream open
+        self.assertIn(1, d._pending)
+
+    def test_ndjson_client_disconnect(self):
+        d, pool = self._make_dispatcher()
+        pool.start(d._response_queue)
+        client = MockClient('GET', '/api/stream')
+        client._connected = False
+        pending = _PendingRequest(client, pool)
+        pending.streaming = True
+        pending.worker_id = 0
+        d._pending[1] = pending
+        d._process_response((MSG_NDJSON, 1, {'x': 1}))
+        # removed from pending
+        self.assertNotIn(1, d._pending)
+        # CTL_DISCONNECT sent to worker's control queue
+        msg = pool._control_queues[0].get(timeout=1)
+        self.assertEqual(msg, (CTL_DISCONNECT, 1))
+        pool.shutdown(timeout=2)
+
+    def test_ndjson_ignored_after_close(self):
+        d, pool = self._make_dispatcher()
+        # no pending request with id 99
+        d._process_response((MSG_NDJSON, 99, {'x': 1}))
+        # should not raise, just ignore
+
     def test_sse_event_ignored_after_close(self):
         d, pool = self._make_dispatcher()
         # no pending request with id 99

{uhttp_workers-1.4.0 → uhttp_workers-1.5.0}/tests/test_worker.py

@@ -8,7 +8,7 @@ from uhttp.workers import (
     Worker, Request, Response, api, RejectRequest, DEFERRED,
     Logger, LOG_DEBUG, LOG_INFO, LOG_WARNING, LOG_ERROR,
     MSG_RESPONSE, MSG_HEARTBEAT,
-    MSG_SSE_OPEN, MSG_SSE_EVENT, MSG_SSE_CLOSE,
+    MSG_SSE_OPEN, MSG_SSE_EVENT, MSG_SSE_CLOSE, MSG_NDJSON,
     CTL_DISCONNECT)
 
 
@@ -520,6 +520,38 @@ class TestSSERequest(unittest.TestCase):
         self.assertIsNone(msg[4])
         self.assertIsNone(msg[5])
 
+    def test_response_ndjson(self):
+        self.req.response_ndjson(
+            headers={'X-Custom': '1'},
+            cookies={'sid': 'abc'})
+        msg = self.queue.get(timeout=1)
+        self.assertEqual(msg[0], MSG_SSE_OPEN)
+        self.assertEqual(msg[1], 10)
+        self.assertEqual(msg[2], 'application/x-ndjson')
+        self.assertEqual(msg[3], {'X-Custom': '1'})
+        self.assertEqual(msg[4], {'sid': 'abc'})
+
+    def test_response_ndjson_defaults(self):
+        self.req.response_ndjson()
+        msg = self.queue.get(timeout=1)
+        self.assertEqual(msg[0], MSG_SSE_OPEN)
+        self.assertEqual(msg[2], 'application/x-ndjson')
+        self.assertIsNone(msg[3])
+        self.assertIsNone(msg[4])
+
+    def test_send_ndjson(self):
+        self.req.send_ndjson({'devices': [1, 2, 3]})
+        msg = self.queue.get(timeout=1)
+        self.assertEqual(msg[0], MSG_NDJSON)
+        self.assertEqual(msg[1], 10)
+        self.assertEqual(msg[2], {'devices': [1, 2, 3]})
+
+    def test_send_ndjson_keepalive(self):
+        self.req.send_ndjson({})
+        msg = self.queue.get(timeout=1)
+        self.assertEqual(msg[0], MSG_NDJSON)
+        self.assertEqual(msg[2], {})
+
     def test_response_stream_end(self):
         self.req.response_stream_end()
         msg = self.queue.get(timeout=1)

{uhttp_workers-1.4.0 → uhttp_workers-1.5.0}/uhttp/workers.py

@@ -23,6 +23,7 @@ MSG_LOG = 'LOG'
 MSG_SSE_OPEN = 'SSE_OPEN'
 MSG_SSE_EVENT = 'SSE_EVENT'
 MSG_SSE_CLOSE = 'SSE_CLOSE'
+MSG_NDJSON = 'NDJSON'
 
 # Worker control messages
 CTL_STOP = 'STOP'
@@ -282,6 +283,25 @@ class Request:
             (MSG_SSE_EVENT, self.request_id,
              data, event, event_id, retry))
 
+    def response_ndjson(self, headers=None, cookies=None):
+        """Start NDJSON streaming response (application/x-ndjson).
+
+        Thin wrapper over response_stream(). Use with DEFERRED — call from
+        handler, then send_ndjson() later. Call response_stream_end() to finish.
+        """
+        self._response_queue.put(
+            (MSG_SSE_OPEN, self.request_id,
+             'application/x-ndjson', headers, cookies))
+
+    def send_ndjson(self, obj):
+        """Send one JSON-serializable object as an NDJSON line.
+
+        Args:
+            obj: any JSON-serializable value (dict/list/str/int/float/bool/None)
+        """
+        self._response_queue.put(
+            (MSG_NDJSON, self.request_id, obj))
+
     def response_stream_end(self):
         """End streaming response and close connection."""
         self._response_queue.put(
@@ -1253,6 +1273,13 @@ class Dispatcher:
                         event_id=event_id, retry=retry)
                 if not ok:
                     self._stream_disconnected(request_id, pending)
+        elif msg_type == MSG_NDJSON:
+            _, request_id, obj = msg
+            pending = self._pending.get(request_id)
+            if pending is not None:
+                ok = pending.client.send_ndjson(obj)
+                if not ok:
+                    self._stream_disconnected(request_id, pending)
         elif msg_type == MSG_SSE_CLOSE:
             _, request_id = msg
             pending = self._pending.pop(request_id, None)

uhttp_workers-1.4.0/README.md → uhttp_workers-1.5.0/uhttp_workers.egg-info/PKG-INFO

@@ -1,3 +1,17 @@
+Metadata-Version: 2.4
+Name: uhttp-workers
+Version: 1.5.0
+Summary: Multi-process worker dispatcher built on uhttp-server
+Author-email: Pavel Revak <pavelrevak@gmail.com>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/pavelrevak/uhttp
+Project-URL: Repository, https://github.com/pavelrevak/uhttp
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: POSIX
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: uhttp-server>=2.5.2
+
 # uhttp-workers
 
 Multi-process worker dispatcher built on [uhttp-server](https://github.com/cortexm/uhttp-server).
@@ -370,6 +384,31 @@ Available streaming methods on `Request`:
 
 Streaming requests are excluded from dispatcher timeout expiration. When the client disconnects, the dispatcher notifies the worker via `on_disconnect(request_id)`.
 
+### NDJSON Streaming
+
+Stream JSON objects line-by-line (`application/x-ndjson`) — one JSON value per line, terminated by `\n`. Useful for incremental APIs that aren't event-shaped (long lists, log tails, progress updates):
+
+```python
+class MyWorker(_workers.Worker):
+    @_workers.api('/devices/scan', 'GET')
+    def scan(self, request):
+        request.response_ndjson()
+        for device in self.discover_devices():
+            request.send_ndjson({'id': device.id, 'name': device.name})
+        request.response_stream_end()
+        return _workers.DEFERRED
+```
+
+NDJSON methods on `Request`:
+
+| Method | Description |
+|--------|-------------|
+| `response_ndjson(headers, cookies)` | Start NDJSON stream (wrapper over `response_stream` with `application/x-ndjson`) |
+| `send_ndjson(obj)` | Send one JSON-serializable value as a line |
+| `response_stream_end()` | End stream and close connection (shared with SSE) |
+
+Same lifecycle as SSE: excluded from timeout expiration, client disconnect triggers `on_disconnect(request_id)`.
+
 ### Flow Control
 
 Workers can stop accepting new requests when busy. Requests stay in the shared pool queue for other workers to pick up:

uhttp_workers-1.5.0/uhttp_workers.egg-info/requires.txt

@@ -0,0 +1 @@
+uhttp-server>=2.5.2

uhttp_workers-1.4.0/uhttp_workers.egg-info/requires.txt

@@ -1 +0,0 @@
-uhttp-server