jsocket 1.9.5__py3-none-any.whl → 1.9.6__py3-none-any.whl

jsocket/__init__.py

@@ -73,3 +73,4 @@
 """
 from jsocket.jsocket_base import *
 from jsocket.tserver import *
+from ._version import __version__

jsocket/_version.py

@@ -0,0 +1,3 @@
+"""Package version."""
+
+__version__ = "1.9.6"

jsocket/jsocket_base.py

@@ -19,14 +19,14 @@ __copyright__= """
     See the License for the specific language governing permissions and
     limitations under the License.
 """
-__version__  = "1.0.3"
-
 import json
 import socket
 import struct
 import logging
 import time
 
+from ._version import __version__
+
 logger = logging.getLogger("jsocket")
 
 
@@ -46,6 +46,7 @@ class JsonSocket:
         self._timeout = timeout
         self._address = address
         self._port = port
+        self._last_client_addr = None
         # Ensure the primary socket respects timeout for accept/connect operations
         self.socket.settimeout(self._timeout)
 
@@ -183,6 +184,7 @@ class JsonServer(JsonSocket):
         """Listen and accept a single client connection; set timeout accordingly."""
         self._listen()
         self.conn, addr = self._accept()
+        self._last_client_addr = addr
         self.conn.settimeout(self.timeout)
         logger.debug(
             "connection accepted, conn socket (%s,%d,%s)", addr[0], addr[1], str(self.conn.gettimeout())

jsocket/tserver.py

@@ -20,15 +20,15 @@ __copyright__= """
     See the License for the specific language governing permissions and
     limitations under the License.
 """
-__version__  = "1.0.3"
-
 import threading
 import socket
 import time
 import logging
 import abc
 from typing import Optional
+
 from jsocket import jsocket_base
+from ._version import __version__
 
 logger = logging.getLogger("jsocket.tserver")
 
@@ -41,6 +41,16 @@ def _response_summary(resp_obj) -> str:
     return f"type={type(resp_obj).__name__}"
 
 
+def _format_client_id(addr) -> str:
+    try:
+        host, port = addr[0], addr[1]
+        if ":" in host:
+            return f"[{host}]:{port}"
+        return f"{host}:{port}"
+    except Exception:  # pylint: disable=broad-exception-caught
+        return "unknown"
+
+
 class ThreadedServer(threading.Thread, jsocket_base.JsonServer, metaclass=abc.ABCMeta):
     """Single-threaded server that accepts one connection and processes messages in its thread."""
 
@@ -48,6 +58,9 @@ class ThreadedServer(threading.Thread, jsocket_base.JsonServer, metaclass=abc.AB
         threading.Thread.__init__(self)
         jsocket_base.JsonServer.__init__(self, **kwargs)
         self._is_alive = False
+        self._stats_lock = threading.Lock()
+        self._client_started_at = None
+        self._client_id = None
 
     @abc.abstractmethod
     def _process_message(self, obj) -> Optional[dict]:
@@ -61,6 +74,32 @@ class ThreadedServer(threading.Thread, jsocket_base.JsonServer, metaclass=abc.AB
         # Return None in the base class to satisfy linters; subclasses should override.
         return None
 
+    def _record_client_start(self):
+        addr = getattr(self, "_last_client_addr", None)
+        if addr is None:
+            try:
+                addr = self.conn.getpeername()
+            except OSError:
+                addr = None
+        with self._stats_lock:
+            self._client_started_at = time.monotonic()
+            self._client_id = _format_client_id(addr)
+
+    def _clear_client_stats(self):
+        with self._stats_lock:
+            self._client_started_at = None
+            self._client_id = None
+
+    def get_client_stats(self) -> dict:
+        """Return connected client count and per-client durations in seconds."""
+        with self._stats_lock:
+            started_at = self._client_started_at
+            client_id = self._client_id
+        if not started_at or not client_id or not self.connected:
+            return {"connected_clients": 0, "clients": {}}
+        duration = time.monotonic() - started_at
+        return {"connected_clients": 1, "clients": {client_id: duration}}
+
     def _accept_client(self) -> bool:
         """Accept an incoming connection; return True when a client connects."""
         try:
@@ -76,6 +115,7 @@ class ThreadedServer(threading.Thread, jsocket_base.JsonServer, metaclass=abc.AB
             logger.debug("server stopping; accept loop exiting (%s:%s)", self.address, self.port)
             self._is_alive = False
             return False
+        self._record_client_start()
         return True
 
     def _handle_client_messages(self):
@@ -99,6 +139,7 @@ class ThreadedServer(threading.Thread, jsocket_base.JsonServer, metaclass=abc.AB
                     logger.debug("handler error (%s): %s", type(e).__name__, e)
                 self._close_connection()
                 break
+        self._clear_client_stats()
 
     def run(self):
         # Ensure the run loop is active even when run() is invoked directly
@@ -132,6 +173,7 @@ class ThreadedServer(threading.Thread, jsocket_base.JsonServer, metaclass=abc.AB
             @retval None 
         """
         self._is_alive = False
+        self._clear_client_stats()
         logger.debug("Threaded Server stopped on %s:%s", self.address, self.port)
 
 
@@ -144,6 +186,8 @@ class ServerFactoryThread(threading.Thread, jsocket_base.JsonSocket, metaclass=a
         self.conn = None
         jsocket_base.JsonSocket.__init__(self, **kwargs)
         self._is_alive = False
+        self._client_started_at = None
+        self._client_id = None
 
     def swap_socket(self, new_sock):
         """ Swaps the existing socket with a new one. Useful for setting socket after a new connection.
@@ -153,6 +197,12 @@ class ServerFactoryThread(threading.Thread, jsocket_base.JsonSocket, metaclass=a
         """
         self.socket = new_sock
         self.conn = self.socket
+        try:
+            addr = new_sock.getpeername()
+        except OSError:
+            addr = None
+        self._client_id = _format_client_id(addr)
+        self._client_started_at = time.monotonic()
 
     def run(self):
         """ Should exit when client closes socket conn.
@@ -215,6 +265,7 @@ class ServerFactory(ThreadedServer):
             raise TypeError("serverThread not of type", ServerFactoryThread)
         self._thread_type = server_thread
         self._threads = []
+        self._threads_lock = threading.Lock()
         self._thread_args = kwargs
         self._thread_args.pop('address', None)
         self._thread_args.pop('port', None)
@@ -245,9 +296,21 @@ class ServerFactory(ThreadedServer):
                     accepted_conn = self.conn
                     # Reset server connection reference so we can accept again
                     self._reset_connection_ref()
+                    if not self._is_alive:
+                        # Server is stopping; close the accepted connection without spawning a worker.
+                        try:
+                            accepted_conn.shutdown(socket.SHUT_RDWR)
+                        except OSError:
+                            pass
+                        try:
+                            accepted_conn.close()
+                        except OSError:
+                            pass
+                        break
                     tmp.swap_socket(accepted_conn)
                     tmp.start()
-                    self._threads.append(tmp)
+                    with self._threads_lock:
+                        self._threads.append(tmp)
                     break
 
         self._wait_to_exit()
@@ -255,14 +318,20 @@ class ServerFactory(ThreadedServer):
 
     def stop_all(self):
         """Stop and join all active worker threads."""
-        for t in self._threads:
-            if t.is_alive():
+        while True:
+            with self._threads_lock:
+                threads = [t for t in self._threads if t.is_alive()]
+            if not threads:
+                break
+            for t in threads:
                 t.force_stop()
                 t.join()
+            self._purge_threads()
 
     def _purge_threads(self):
         # Rebuild list to avoid mutating while iterating
-        self._threads = [t for t in self._threads if t.is_alive()]
+        with self._threads_lock:
+            self._threads = [t for t in self._threads if t.is_alive()]
 
     def stop(self):
         # Stop accepting and stop all workers
@@ -279,6 +348,25 @@ class ServerFactory(ThreadedServer):
             time.sleep(0.2)
 
     def _get_num_of_active_threads(self):
-        return len([True for x in self._threads if x.is_alive()])
+        with self._threads_lock:
+            threads = list(self._threads)
+        return len([True for x in threads if x.is_alive()])
+
+    def get_client_stats(self) -> dict:
+        """Return connected client count and per-client durations in seconds."""
+        with self._threads_lock:
+            threads = list(self._threads)
+        now = time.monotonic()
+        clients = {}
+        active = 0
+        for t in threads:
+            if not t.is_alive():
+                continue
+            active += 1
+            started_at = getattr(t, "_client_started_at", None)
+            client_id = getattr(t, "_client_id", None) or f"thread-{t.name}"
+            duration = now - started_at if started_at else 0.0
+            clients[client_id] = duration
+        return {"connected_clients": active, "clients": clients}
 
     active = property(_get_num_of_active_threads, doc="number of active threads")

jsocket-1.9.6.dist-info/METADATA

@@ -0,0 +1,166 @@
+Metadata-Version: 2.4
+Name: jsocket
+Version: 1.9.6
+Summary: Python JSON Server & Client
+Author-email: Christopher Piekarski <chris@cpiekarski.com>
+Maintainer-email: Christopher Piekarski <chris@cpiekarski.com>
+License-Expression: Apache-2.0
+Project-URL: Homepage, https://cpiekarski.com/2012/01/25/python-json-client-server-redux/
+Keywords: json,socket,server,client
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Operating System :: OS Independent
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Topic :: System :: Networking
+Classifier: Topic :: Software Development :: Libraries :: Application Frameworks
+Classifier: Topic :: System :: Distributed Computing
+Classifier: Topic :: System :: Hardware :: Symmetric Multi-processing
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+python-json-socket (jsocket)
+============================
+
+[![CI](https://github.com/chris-piekarski/python-json-socket/actions/workflows/ci.yml/badge.svg)](https://github.com/chris-piekarski/python-json-socket/actions/workflows/ci.yml)
+![PyPI](https://img.shields.io/pypi/v/jsocket.svg)
+![Python Versions](https://img.shields.io/pypi/pyversions/jsocket.svg)
+![License](https://img.shields.io/pypi/l/jsocket.svg)
+
+Simple JSON-over-TCP sockets for Python. This library provides:
+
+- JsonClient/JsonServer: length‑prefixed JSON message framing over TCP
+- ThreadedServer: a single-connection server running in its own thread
+- ServerFactory/ServerFactoryThread: a per‑connection worker model for multiple clients
+
+It aims to be small, predictable, and easy to integrate in tests or small services.
+
+
+Install
+-------
+
+```
+pip install jsocket
+```
+
+Requires Python 3.8+.
+
+
+Quickstart
+----------
+
+Echo server with `ThreadedServer` and a client:
+
+```python
+import time
+import jsocket
+
+class Echo(jsocket.ThreadedServer):
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+        self.timeout = 2.0
+
+    # Return a dict to send a response back to the client
+    def _process_message(self, obj):
+        if isinstance(obj, dict) and 'echo' in obj:
+            return obj
+        return None
+
+# Bind to an ephemeral port (port=0)
+server = Echo(address='127.0.0.1', port=0)
+_, port = server.socket.getsockname()
+server.start()
+
+client = jsocket.JsonClient(address='127.0.0.1', port=port)
+assert client.connect() is True
+
+payload = {"echo": "hello"}
+client.send_obj(payload)
+assert client.read_obj() == payload
+
+client.close()
+server.stop()
+server.join()
+```
+
+Per‑connection workers with `ServerFactory`:
+
+```python
+import jsocket
+
+class Worker(jsocket.ServerFactoryThread):
+    def __init__(self):
+        super().__init__()
+        self.timeout = 2.0
+
+    def _process_message(self, obj):
+        if isinstance(obj, dict) and 'message' in obj:
+            return {"reply": f"got: {obj['message']}"}
+
+server = jsocket.ServerFactory(Worker, address='127.0.0.1', port=5489)
+server.start()
+# Connect one or more clients; one Worker is spawned per connection
+```
+
+
+API Highlights
+--------------
+
+- JsonClient:
+  - `connect()` returns True on success
+  - `send_obj(dict)` sends a JSON object
+  - `read_obj()` blocks until a full message is received; raises `socket.timeout` or `RuntimeError("socket connection broken")`
+  - `timeout` property controls socket timeouts
+
+- ThreadedServer:
+  - Subclass and implement `_process_message(self, obj) -> Optional[dict]`
+  - Return a dict to send a response; return `None` to send nothing
+  - `start()`, `stop()`, `join()` manage the server thread
+  - `send_obj(dict)` sends to the currently connected client
+
+- ServerFactory / ServerFactoryThread:
+  - `ServerFactoryThread` is a worker that handles one client connection
+  - `ServerFactory` accepts connections and spawns a worker per client
+
+
+Examples and Tests
+------------------
+
+- Examples: see `examples/example_servers.py` and `scripts/smoke_test.py`
+- Pytest: end-to-end and listener tests under `tests/`
+  - Run: `pytest -q`
+
+
+Behavior-Driven Tests (Behave)
+------------------------------
+
+- Steps live under `features/steps/` and environment hooks in `features/environment.py`.
+- To run Behave scenarios, add one or more `.feature` files under `features/` and run:
+  - `pip install -r requirements-dev.txt`
+  - `PYTHONPATH=. behave -f progress2`
+- A minimal example feature:
+
+  ```gherkin
+  Feature: Echo round-trip
+    Scenario: client/server echo
+      Given I start the server
+      And I connect the client
+      When the client sends the object {"echo": "hi"}
+      Then the client sees a message {"echo": "hi"}
+  ```
+
+
+Notes
+-----
+
+- Message framing uses a 4‑byte big‑endian length header followed by a JSON payload encoded as UTF‑8.
+- On disconnect, reads raise `RuntimeError("socket connection broken")` so callers can distinguish cleanly from timeouts.
+- Binding with `port=0` lets the OS choose an ephemeral port; find it with `server.socket.getsockname()`.
+
+
+Links
+-----
+
+- PyPI: https://pypi.org/project/jsocket/
+- License: see `LICENSE`

jsocket-1.9.6.dist-info/RECORD

@@ -0,0 +1,9 @@
+jsocket/__init__.py,sha256=V2M4mp2IwcL1Zy_yoD-6Y5h7PO2sdt5Plf1U0Xw27N8,2870
+jsocket/_version.py,sha256=qOzpkpbIx06kwOoN9b1utOqUXOBX3mBIrcqYtuZOMkQ,46
+jsocket/jsocket_base.py,sha256=lc72kDs-6ID-e4006jiVCZPRhVsRIDuQrSV5-oSdah0,8112
+jsocket/tserver.py,sha256=h19so2UgUc1RIMmkNcJamwZ7gbFFGmaSJqrI2l6XUts,14098
+jsocket-1.9.6.dist-info/licenses/LICENSE,sha256=TIwob4kUNx1DKZ0NVKToEDAFgWsevvTgtZgr_obkDhg,11355
+jsocket-1.9.6.dist-info/METADATA,sha256=ebDsoiSN1UF_vqugNBMPWlA54HVCzeodYN7ow1kvwPE,5082
+jsocket-1.9.6.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+jsocket-1.9.6.dist-info/top_level.txt,sha256=QqfmeUi7avy9cdcsVVvG68CP-4mfg_P6E7OuBuNEcN4,8
+jsocket-1.9.6.dist-info/RECORD,,

{jsocket-1.9.5.dist-info → jsocket-1.9.6.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: bdist_wheel (0.37.1)
+Generator: setuptools (80.10.2)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

jsocket-1.9.5.dist-info/METADATA

@@ -1,27 +0,0 @@
-Metadata-Version: 2.1
-Name: jsocket
-Version: 1.9.5
-Summary: Python JSON Server & Client
-Home-page: https://cpiekarski.com/2012/01/25/python-json-client-server-redux/
-Author: Christopher Piekarski
-Author-email: chris@cpiekarski.com
-Maintainer: Christopher Piekarski
-Maintainer-email: chris@cpiekarski.com
-License: OSI Approved Apache Software License
-Keywords: json,socket,server,client
-Platform: UNKNOWN
-Classifier: Intended Audience :: Developers
-Classifier: License :: OSI Approved :: Apache Software License
-Classifier: Programming Language :: Python :: 3.9
-Classifier: Operating System :: OS Independent
-Classifier: Development Status :: 5 - Production/Stable
-Classifier: Topic :: System :: Networking
-Classifier: Topic :: Software Development :: Libraries :: Application Frameworks
-Classifier: Topic :: System :: Distributed Computing
-Classifier: Topic :: System :: Hardware :: Symmetric Multi-processing
-Provides: jsocket
-Requires-Python: >=3.8
-License-File: LICENSE
-
-UNKNOWN
-

jsocket-1.9.5.dist-info/RECORD

@@ -1,8 +0,0 @@
-jsocket/__init__.py,sha256=Im4nFil0iBOXF0G5K5I2nVMkSDIlGNev-rOjy3XUwn8,2836
-jsocket/jsocket_base.py,sha256=65-0DMdgQKymiE3poBpvRnyTMgEv3-VOfqWe-C-6ge4,8025
-jsocket/tserver.py,sha256=bez8pKWwzPQXD0R33sTV-6Z579DS4vfQnnPkklzxt64,10746
-jsocket-1.9.5.dist-info/LICENSE,sha256=TIwob4kUNx1DKZ0NVKToEDAFgWsevvTgtZgr_obkDhg,11355
-jsocket-1.9.5.dist-info/METADATA,sha256=hV3r6UToy38ZkkrSi8ohRGndzCN_xYa8329Ue_hUhXQ,983
-jsocket-1.9.5.dist-info/WHEEL,sha256=G16H4A3IeoQmnOrYV4ueZGKSjhipXx8zc8nu9FGlvMA,92
-jsocket-1.9.5.dist-info/top_level.txt,sha256=QqfmeUi7avy9cdcsVVvG68CP-4mfg_P6E7OuBuNEcN4,8
-jsocket-1.9.5.dist-info/RECORD,,