farsounder 0.1.0__py3-none-any.whl → 0.1.1__py3-none-any.whl

farsounder/client/requests.py

@@ -1,11 +1,9 @@
 from __future__ import annotations
 
-import asyncio
 from typing import TypeVar
 
 import httpx
 import zmq
-import zmq.asyncio
 from google.protobuf.message import Message
 
 from farsounder.proto.proto import nav_api_pb2 as nav_api
@@ -21,24 +19,27 @@ from farsounder.client.history_types import HistoryData
 ResponseT = TypeVar("ResponseT", bound=Message)
 
 
-async def _request(
+def _request(
     config: ClientConfig,
     endpoint: ReqRepEndpoint,
     request: Message,
     response_cls: type[ResponseT],
 ) -> ResponseT:
-    ctx = zmq.asyncio.Context.instance()
+    ctx = zmq.Context.instance()
     socket = ctx.socket(zmq.REQ)
     try:
         port = resolve_reqrep_port(config, endpoint)
         socket.connect(f"tcp://{config.host}:{port}")
-        await socket.send(request.SerializeToString())
-        try:
-            data = await asyncio.wait_for(socket.recv(), timeout=config.timeout_seconds)
-        except asyncio.TimeoutError as exc:
+        socket.send(request.SerializeToString())
+        poller = zmq.Poller()
+        poller.register(socket, zmq.POLLIN)
+        timeout_ms = int(config.timeout_seconds * 1000)
+        events = dict(poller.poll(timeout=timeout_ms))
+        if socket not in events:
             raise RequestTimeoutError(
                 f"Timeout waiting for {endpoint} after {config.timeout_seconds:.1f}s"
-            ) from exc
+            )
+        data = socket.recv()
     finally:
         socket.close(linger=0)
 
@@ -47,7 +48,7 @@ async def _request(
     return response
 
 
-async def get_processor_settings(
+def get_processor_settings(
     config: ClientConfig,
 ) -> nav_api.GetProcessorSettingsResponse:
     """Request the current processor settings.
@@ -64,7 +65,7 @@ async def get_processor_settings(
     """
 
     request = nav_api.GetProcessorSettingsRequest()
-    return await _request(
+    return _request(
         config,
         "GetProcessorSettings",
         request,
@@ -72,7 +73,7 @@ async def get_processor_settings(
     )
 
 
-async def set_field_of_view(
+def set_field_of_view(
     fov: nav_api.FieldOfView,
     config: ClientConfig,
 ) -> nav_api.SetFieldOfViewResponse:
@@ -92,7 +93,7 @@ async def set_field_of_view(
     """
 
     request = nav_api.SetFieldOfViewRequest(fov=fov)
-    return await _request(
+    return _request(
         config,
         "SetFieldOfView",
         request,
@@ -100,7 +101,7 @@ async def set_field_of_view(
     )
 
 
-async def set_bottom_detection(
+def set_bottom_detection(
     enable: bool,
     config: ClientConfig,
 ) -> nav_api.SetBottomDetectionResponse:
@@ -120,7 +121,7 @@ async def set_bottom_detection(
     """
 
     request = nav_api.SetBottomDetectionRequest(enable_bottom_detection=enable)
-    return await _request(
+    return _request(
         config,
         "SetBottomDetection",
         request,
@@ -128,7 +129,7 @@ async def set_bottom_detection(
     )
 
 
-async def set_inwater_squelch(
+def set_inwater_squelch(
     value: float,
     config: ClientConfig,
 ) -> nav_api.SetInWaterSquelchResponse:
@@ -148,7 +149,7 @@ async def set_inwater_squelch(
     """
 
     request = nav_api.SetInWaterSquelchRequest(new_squelch_val=value)
-    return await _request(
+    return _request(
         config,
         "SetInWaterSquelch",
         request,
@@ -156,7 +157,7 @@ async def set_inwater_squelch(
     )
 
 
-async def set_squelchless_inwater_detector(
+def set_squelchless_inwater_detector(
     enable: bool,
     config: ClientConfig,
 ) -> nav_api.SetSquelchlessInWaterDetectorResponse:
@@ -178,7 +179,7 @@ async def set_squelchless_inwater_detector(
     request = nav_api.SetSquelchlessInWaterDetectorRequest(
         enable_squelchless_detection=enable
     )
-    return await _request(
+    return _request(
         config,
         "SetSquelchlessInWaterDetector",
         request,
@@ -186,7 +187,7 @@ async def set_squelchless_inwater_detector(
     )
 
 
-async def get_vessel_info(
+def get_vessel_info(
     config: ClientConfig,
 ) -> nav_api.GetVesselInfoResponse:
     """Request the current vessel info.
@@ -203,9 +204,7 @@ async def get_vessel_info(
     """
 
     request = nav_api.GetVesselInfoRequest()
-    return await _request(
-        config, "GetVesselInfo", request, nav_api.GetVesselInfoResponse
-    )
+    return _request(config, "GetVesselInfo", request, nav_api.GetVesselInfoResponse)
 
 
 def _build_history_params(
@@ -233,7 +232,7 @@ def _build_history_params(
     return params
 
 
-async def get_history_data(
+def get_history_data(
     config: ClientConfig,
     *,
     latitude: float,
@@ -287,13 +286,17 @@ async def get_history_data(
     )
     url = f"http://{config.host}:{port}/api/history_data"
     try:
-        async with httpx.AsyncClient(timeout=config.timeout_seconds) as client:
-            response = await client.get(url, params=params)
+        with httpx.Client(timeout=config.timeout_seconds) as client:
+            response = client.get(url, params=params)
         response.raise_for_status()
     except httpx.ConnectError as exc:
         raise httpx.ConnectError(
             f"Failed to connect to {url}, is the server running?"
         ) from exc
+    except httpx.ConnectTimeout as exc:
+        raise RequestTimeoutError(
+            f"Timeout waiting for {url} after {config.timeout_seconds:.1f}s"
+        ) from exc
 
     history_count = None
     if include_count:

farsounder/client/subscriber.py

@@ -1,12 +1,12 @@
 from __future__ import annotations
 
-import asyncio
 import logging
+import threading
 from collections.abc import Callable, Iterable
-from typing import Awaitable, Literal
+from concurrent.futures import Future, ThreadPoolExecutor
+from typing import Literal
 
 import zmq
-import zmq.asyncio
 from google.protobuf.message import Message
 
 from farsounder.proto.proto import nav_api_pb2 as nav_api
@@ -19,7 +19,7 @@ from farsounder.client.config import (
 
 logger = logging.getLogger(__name__)
 
-MessageCallback = Callable[[Message], Awaitable[None] | None]
+MessageCallback = Callable[[Message], None]
 
 PUBSUB_MESSAGE_CLASSES: dict[PubSubMessage, type[Message]] = {
     "HydrophoneData": nav_api.HydrophoneData,
@@ -30,18 +30,20 @@ PUBSUB_MESSAGE_CLASSES: dict[PubSubMessage, type[Message]] = {
 
 
 class Subscription:
-    """Async subscription to pub-sub messages."""
+    """Subscription to pub-sub messages using background threads."""
 
     def __init__(self, config: ClientConfig) -> None:
         self._config = config
         self._callbacks: dict[PubSubMessage, list[MessageCallback]] = {
             message_type: [] for message_type in PUBSUB_MESSAGE_CLASSES
         }
-        self._ctx = zmq.asyncio.Context.instance()
-        self._sockets: dict[PubSubMessage, zmq.asyncio.Socket] = {}
-        self._tasks: list[asyncio.Task[None]] = []
+        self._threads: list[threading.Thread] = []
         self._running = False
+        self._stop_event = threading.Event()
         self._use_threadpool = config.callback_executor == "threadpool"
+        self._executor: ThreadPoolExecutor | None = (
+            ThreadPoolExecutor() if self._use_threadpool else None
+        )
 
     def on(self, message_type: PubSubMessage, callback: MessageCallback) -> None:
         """Register a callback for a pub-sub message type.
@@ -59,92 +61,107 @@ class Subscription:
             raise ValueError(f"Unknown pub-sub message type: {message_type}")
         self._callbacks[message_type].append(callback)
 
-    async def start(self) -> None:
-        """Start background receive tasks for subscribed message types."""
+    def start(self) -> None:
+        """Start background receive threads for subscribed message types."""
 
         if self._running:
             return
         self._running = True
+        self._stop_event.clear()
+        if self._use_threadpool and self._executor is None:
+            self._executor = ThreadPoolExecutor()
 
         for message_type in self._config.subscribe:
-            port = resolve_pubsub_port(self._config, message_type)
-            socket = self._ctx.socket(zmq.SUB)
-            socket.setsockopt(zmq.SUBSCRIBE, b"")
-            socket.connect(f"tcp://{self._config.host}:{port}")
-            self._sockets[message_type] = socket
-            self._tasks.append(
-                asyncio.create_task(self._recv_loop(message_type, socket))
+            thread = threading.Thread(
+                target=self._recv_loop,
+                args=(message_type,),
+                name=f"farsounder-sub-{message_type}",
+                daemon=True,
             )
+            thread.start()
+            self._threads.append(thread)
 
-    async def stop(self) -> None:
-        """Stop background receive tasks and close sockets."""
+    def stop(self) -> None:
+        """Stop background receive threads."""
 
         if not self._running:
             return
         self._running = False
+        self._stop_event.set()
 
-        for task in self._tasks:
-            task.cancel()
-        await asyncio.gather(*self._tasks, return_exceptions=True)
-        self._tasks.clear()
+        for thread in self._threads:
+            thread.join()
+        self._threads.clear()
 
-        for socket in self._sockets.values():
-            socket.close(linger=0)
-        self._sockets.clear()
+        if self._executor is not None:
+            self._executor.shutdown(wait=True)
+            self._executor = None
 
-    async def __aenter__(self) -> "Subscription":
-        await self.start()
+    def __enter__(self) -> "Subscription":
+        self.start()
         return self
 
-    async def __aexit__(self, exc_type, exc, tb) -> None:
-        await self.stop()
+    def __exit__(self, exc_type, exc, tb) -> None:
+        self.stop()
 
-    async def _recv_loop(
-        self, message_type: PubSubMessage, socket: zmq.asyncio.Socket
-    ) -> None:
+    def _recv_loop(self, message_type: PubSubMessage) -> None:
+        port = resolve_pubsub_port(self._config, message_type)
+        socket = zmq.Context.instance().socket(zmq.SUB)
+        socket.setsockopt(zmq.SUBSCRIBE, b"")
+        socket.connect(f"tcp://{self._config.host}:{port}")
+        poller = zmq.Poller()
+        poller.register(socket, zmq.POLLIN)
         message_cls = PUBSUB_MESSAGE_CLASSES[message_type]
-        while True:
-            try:
-                data = await socket.recv()
-            except asyncio.CancelledError:
-                break
-            except Exception:
-                logger.exception("Failed to receive %s", message_type)
-                continue
-
-            try:
-                message = message_cls()
-                message.ParseFromString(data)
-            except Exception:
-                logger.exception("Failed to parse %s", message_type)
-                continue
-
-            self._dispatch(message_type, message)
+        try:
+            while not self._stop_event.is_set():
+                try:
+                    events = dict(poller.poll(timeout=1000))
+                except Exception:
+                    if self._stop_event.is_set():
+                        break
+                    logger.exception("Failed to poll %s", message_type)
+                    continue
+
+                if socket not in events:
+                    continue
+
+                try:
+                    data = socket.recv()
+                except Exception:
+                    if self._stop_event.is_set():
+                        break
+                    logger.exception("Failed to receive %s", message_type)
+                    continue
+
+                try:
+                    message = message_cls()
+                    message.ParseFromString(data)
+                except Exception:
+                    logger.exception("Failed to parse %s", message_type)
+                    continue
+
+                self._dispatch(message_type, message)
+        finally:
+            socket.close(linger=0)
 
     def _dispatch(self, message_type: PubSubMessage, message: Message) -> None:
         callbacks = list(self._callbacks.get(message_type, []))
         if not callbacks:
             return
 
-        loop = asyncio.get_running_loop()
         for callback in callbacks:
-            if self._use_threadpool and not asyncio.iscoroutinefunction(callback):
-                future = loop.run_in_executor(None, callback, message)
+            if self._use_threadpool and self._executor is not None:
+                future = self._executor.submit(callback, message)
                 future.add_done_callback(self._log_task_result)
                 continue
 
             try:
-                result = callback(message)
+                callback(message)
             except Exception:
                 logger.exception("Callback error for %s", message_type)
-                continue
-
-            if asyncio.iscoroutine(result):
-                task = asyncio.create_task(result)
-                task.add_done_callback(self._log_task_result)
 
     @staticmethod
-    def _log_task_result(task: asyncio.Future[object]) -> None:
+    def _log_task_result(task: Future[object]) -> None:
         try:
             task.result()
         except Exception:

{farsounder-0.1.0.dist-info → farsounder-0.1.1.dist-info}/METADATA

@@ -1,18 +1,25 @@
 Metadata-Version: 2.4
 Name: farsounder
-Version: 0.1.0
+Version: 0.1.1
 Summary: Python client to communicate with FarSounder's ARGOS sensors
 Author-email: FarSounder Software Team <sw@farsounder.com>
 Requires-Python: >=3.13
 Description-Content-Type: text/markdown
+License-File: LICENSE
 Requires-Dist: httpx
 Requires-Dist: protobuf
 Requires-Dist: pyzmq
+Dynamic: license-file
 
-# SDK Client for live FarSounder data
+# Python API Client for Argos data
 
 Python client to communicate with SonaSoft via API.
 
+>[!NOTE]
+> This is still under active development and testing. But may serve as an example for
+> integration, beyond the lower level example in [sdk repo](https://github.com/farsounder/SDK-Integration-Examples).
+> For now the docs are the interfaces and the examples in examples/
+
 ## Usage
 
 Clone locally and install (uv add .) or install from pypi like:
@@ -25,47 +32,63 @@ uv add farsounder
 Then - for example to subscribe to `TargetData` messages:
 
 ```python
-import asyncio
+import time
 
 from farsounder import config, requests, subscriber
 from farsounder.proto import nav_api_pb2
 
 
-async def main() -> None:
+def main() -> None:
+
+    # Build the configuration:
+    # - where is the api running?
+    # - what messages do you care about subscribing to?
+    # - if ports are changed, they can overridden here
     cfg = config.build_config(
         host="127.0.0.1",
         subscribe=["TargetData"],
     )
 
-    sub = subscriber.subscribe(config)
 
+    # Pub/Sub
+    sub = subscriber.subscribe(cfg)
+    # A callback to run when there are new target data messages
+    # - don't do a lot of processing in here it will block (thank GIL - for now...)
+    # - use sync mechanism if you're accessing shared data (callbacks
+    #   run on thread pool [default] or on the receive thread for the message
+    #   type)
     def on_targets(message: nav_api_pb2.TargetData) -> None:
         print("Got a TargetData!")
         print("Targets:", len(message.groups))
 
-    # Pub/Sub
+    # register the callback(s)
     sub.on("TargetData", on_targets)
-    await sub.start()
+
+    # start the receive loop
+    sub.start()
 
     # Req/rep
-    settings = await requests.get_processor_settings(config)
+    # for each of the request / reply endpoints - there are specific
+    # get/set functions
+    settings = requests.get_processor_settings(cfg)
     print(settings)
 
-    # History data
-    history = await requests.get_history_data(
-        config,
+    history = requests.get_history_data(
+        cfg,
         latitude=41.7223,
         longitude=-71.35,
         radius_meters=500,
     )
     print(history.gridded_bottom_detections)
 
-    await asyncio.sleep(1.0)
-    await sub.stop()
+    time.sleep(1.0)
+
+    # Stop receive loop
+    sub.stop()
 
 
 if __name__ == "__main__":
-    asyncio.run(main())
+    main()
 ```
 
 ## Simulated backend

{farsounder-0.1.0.dist-info → farsounder-0.1.1.dist-info}/RECORD

@@ -3,8 +3,8 @@ farsounder/client/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU
 farsounder/client/config.py,sha256=toTQ9hjLps4OJJYdN8WMk9O3yRTTmUQbKDLXWdZmxM0,4596
 farsounder/client/exceptions.py,sha256=CLMtiQwe7zRKL4swq5Xl8p1Xo_jutpKov3YCmDMp0PI,88
 farsounder/client/history_types.py,sha256=NkZV9wwPdUMOz_hamyUjMvx8p9BPbAE6WNKA1OZd7yQ,3358
-farsounder/client/requests.py,sha256=_YV0qWOymdwnN2kkKwkLJ1LTR4llXlKtcDBd97IMOOM,8115
-farsounder/client/subscriber.py,sha256=0WH93zKj9S_SOVnjuFIPVfgOwSXc2k8b9f45-i0ihog,6234
+farsounder/client/requests.py,sha256=LhX1KYQv91k_GlHZp2T3qC5Xu7ggT32pSZHZfSo1IJQ,8218
+farsounder/client/subscriber.py,sha256=O_KWCR0kqt8E1cfiKNypAGS8gC-fL68idK2Vj1ybFdE,6803
 farsounder/proto/__init__.py,sha256=srUEbuHuHHVMvPgQY9z4PmprVai78cleAYN34oiKcHI,824
 farsounder/proto/proto/__init__.py,sha256=jNeAvw99gdQ6m2XO8vtp05Sp3v-MVFzPhDxtttOBXUg,76
 farsounder/proto/proto/array_pb2.py,sha256=7q7vr6AtUIc1z31Q521XRHb5CeCuZEFvmp5E4nPLWuo,2170
@@ -19,8 +19,9 @@ farsounder/proto/proto/nmea_pb2.py,sha256=jTmHhkrP1EOJxIy9coh2WM2_Po_2BUt41ovGqV
 farsounder/proto/proto/nmea_pb2.pyi,sha256=Jz18Kr61182b1JLNLSSoajuODeIGP4vzQnjImxRw9AE,795
 farsounder/proto/proto/time_pb2.py,sha256=WEc9S8-Qk0mE3W5H76ruancCxKrA5y6sGYkM4Jjz2tU,1542
 farsounder/proto/proto/time_pb2.pyi,sha256=dVAMCH_pxbYeCKDgIBAZPYa9Rpj52hB8MXeRFWyPeD0,950
-farsounder-0.1.0.dist-info/METADATA,sha256=NYJux9H6WuY_ks7C5gJF0jS8lQyr2LjD2Q0Km07uKcM,2155
-farsounder-0.1.0.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
-farsounder-0.1.0.dist-info/entry_points.txt,sha256=JKbKYe7jA1DvRuucj2jO8mXd3Bipb2BoPvxF0clcQWg,64
-farsounder-0.1.0.dist-info/top_level.txt,sha256=B7BR-Oj3C_D1nEICNpZt19anMsV8Ozxt836-R4VhTcs,11
-farsounder-0.1.0.dist-info/RECORD,,
+farsounder-0.1.1.dist-info/licenses/LICENSE,sha256=Emjj_IK4M3YYqy_ziQr96CSknkIfzQG3za-kQw9gcW0,908
+farsounder-0.1.1.dist-info/METADATA,sha256=Fj731yUyJqy83iJtWRz_FxQx88tM2bWKLAREpzIRpBU,3083
+farsounder-0.1.1.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+farsounder-0.1.1.dist-info/entry_points.txt,sha256=JKbKYe7jA1DvRuucj2jO8mXd3Bipb2BoPvxF0clcQWg,64
+farsounder-0.1.1.dist-info/top_level.txt,sha256=B7BR-Oj3C_D1nEICNpZt19anMsV8Ozxt836-R4VhTcs,11
+farsounder-0.1.1.dist-info/RECORD,,

farsounder-0.1.1.dist-info/licenses/LICENSE

@@ -0,0 +1,15 @@
+# Licensing
+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.
+
+The SonaSoft SDK is provided free of charge for non-commercial applications, 
+development partners are still required to sign a licensing agreement with
+FarSounder to receive the complete SDK materials (the SonaSoft demo software)
+and eventually to become an authorized third-party integrator. Please contact
+us at service@farsounder.com to complete the licensing agreement or discuss use 
+for commercial applications.