helius-python 0.5.0__tar.gz → 0.5.2__tar.gz

{helius_python-0.5.0 → helius_python-0.5.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: helius-python
-Version: 0.5.0
+Version: 0.5.2
 Summary: Typed Python client for the Helius API
 Project-URL: Homepage, https://github.com/markosnarinian/helius-python
 Project-URL: Issues, https://github.com/markosnarinian/helius-python/issues

{helius_python-0.5.0 → helius_python-0.5.2}/pyproject.toml

@@ -10,7 +10,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "helius-python"
-version = "0.5.0"
+version = "0.5.2"
 authors = [
   { name="Markos Narinian", email="manarinian@gmail.com" },
 ]

{helius_python-0.5.0 → helius_python-0.5.2}/src/helius/laserstream/websockets.py

@@ -132,6 +132,10 @@ class WebSocketClient:
         base_url="wss://mainnet.helius-rpc.com",
         api_key: str | None = None,
         proxy: str | None = None,
+        open_timeout: float | None = 10,
+        ping_interval: float | None = 20,
+        ping_timeout: float | None = 20,
+        close_timeout: float | None = 10,
     ):
 
         base_url = base_url
@@ -144,7 +148,14 @@ class WebSocketClient:
         if not api_key:
             raise ValueError("No API key provided.")
         uri = httpx.URL(base_url).copy_with(path="/", params={"api-key": api_key})
-        self._websocket = connect(str(uri), proxy=proxy)
+        self._websocket = connect(
+            str(uri),
+            proxy=proxy,
+            open_timeout=open_timeout,
+            ping_interval=ping_interval,
+            ping_timeout=ping_timeout,
+            close_timeout=close_timeout,
+        )
 
     def close(self):
         self._websocket.close()
@@ -163,6 +174,27 @@ class WebSocketClient:
         response = self._websocket.recv()
         return json.loads(response)
 
+    def receive(self) -> tuple[dict | None, Notification, int]:
+        response = json.loads(self._websocket.recv())
+        model = self.MODELS[response["method"]]
+        result = response["params"]["result"]
+        subscription = response["params"]["subscription"]
+        if isinstance(result, dict):
+            context = result.get("context")
+            value = result.get("value")
+        else:
+            context, value = None, None
+        if value is not None:
+            notification = model.model_validate(value)
+        else:
+            notification = model.model_validate(result)
+        return context, notification, subscription
+
+    def listen(self):
+        while True:
+            context, notification, subscription = self.receive()
+            yield context, notification, subscription
+
     def _unsubscribe(self, subscription_type, subscription) -> bool:
         request = (
             JsonRpcRequest(method=f"{subscription_type}Unsubscribe")
@@ -376,24 +408,3 @@ class WebSocketClient:
 
     def vote_unsubscribe(self, subscription) -> bool:
         return self._unsubscribe("vote", subscription)
-
-    def receive(self) -> tuple[dict | None, Notification, int]:
-        response = json.loads(self._websocket.recv())
-        model = self.MODELS[response["method"]]
-        result = response["params"]["result"]
-        subscription = response["params"]["subscription"]
-        if isinstance(result, dict):
-            context = result.get("context")
-            value = result.get("value")
-        else:
-            context, value = None, None
-        if value is not None:
-            notification = model.model_validate(value)
-        else:
-            notification = model.model_validate(result)
-        return context, notification, subscription
-
-    def listen(self):
-        while True:
-            context, notification, subscription = self.receive()
-            yield context, notification, subscription

{helius_python-0.5.0 → helius_python-0.5.2}/test_examples.py

@@ -9,13 +9,15 @@ Usage:
     .venv/bin/python test_examples.py
 
 The runner expects `HELIUS_API_KEY` to be available in the environment or in
-`.env`, matching the examples themselves. Some Helius endpoints are plan-gated
-or network-gated; those failures are reported as "external" instead of as
-example runtime bugs.
+`.env`, matching the examples themselves. Missing/unauthorized API key failures
+are reported as "auth" instead of as example runtime bugs. Some Helius endpoints
+are plan-gated or network-gated; other failures in that class are reported as
+"external".
 """
 
 from __future__ import annotations
 
+import argparse
 import os
 import subprocess
 import sys
@@ -28,6 +30,7 @@ USE_COLOR = "NO_COLOR" not in os.environ
 
 GREEN = "\033[32m"
 YELLOW = "\033[33m"
+ORANGE = "\033[38;5;208m"
 RED = "\033[31m"
 BOLD = "\033[1m"
 RESET = "\033[0m"
@@ -37,6 +40,16 @@ SMALL_MINT = "J5iyNuTa6zqqA62Xe4h1VBvcBW5CTSNNva3QPh8DU5RV"
 KNOWN_SIGNATURE = "eqRntqi1tjXv1zEGBM5btQGWoxWc73XXGDJXjxLE65Atj6T6qzNnJf5LyTbUoGXHS9TzeAnQniAre48SjcJft9f"
 DEVNET_ADDRESS = "7xKXtg2CW87d97TXJSDpbD5jBkheTqA83TZRuJosgAsU"
 
+AUTH_FAILURE_MARKERS = (
+    "No API key provided.",
+    "HTTP 401",
+    "401 Unauthorized",
+    "HTTP 403",
+    "403 Forbidden",
+    "Unauthorized",
+    "Forbidden",
+)
+
 
 @dataclass(frozen=True)
 class ExampleTest:
@@ -118,8 +131,6 @@ TESTS = [
         timeout=45,
         external_failure_markers=(
             "TimeoutError: timed out",
-            "403 Forbidden",
-            "HTTP 403",
         ),
     ),
     ExampleTest(
@@ -141,6 +152,41 @@ def color(text: str, ansi_color: str) -> str:
     return f"{ansi_color}{text}{RESET}"
 
 
+def parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument(
+        "-v",
+        action="count",
+        default=0,
+        dest="verbose_count",
+        help="increase verbosity; use -v for level 1 or -vv for level 2",
+    )
+    parser.add_argument(
+        "--verbose",
+        type=int,
+        choices=(0, 1, 2),
+        default=None,
+        help=(
+            "0: only results and failure names; "
+            "1: include script output for non-passing tests; "
+            "2: include script output for all tests"
+        ),
+    )
+    args = parser.parse_args()
+    args.verbose = (
+        args.verbose if args.verbose is not None else min(args.verbose_count, 2)
+    )
+    return args
+
+
+def output_preview(output: str) -> str:
+    lines = output.strip().splitlines()
+    preview = "\n".join(lines[:30])
+    if len(lines) > 30:
+        preview += f"\n... ({len(lines) - 30} more lines)"
+    return preview
+
+
 def run_example(test: ExampleTest) -> tuple[str, str]:
     env = os.environ.copy()
     env["PYTHONPATH"] = (
@@ -167,47 +213,60 @@ def run_example(test: ExampleTest) -> tuple[str, str]:
     output = result.stdout + result.stderr
     if result.returncode == 0:
         return "passed", output
+    if any(marker in output for marker in AUTH_FAILURE_MARKERS):
+        return "auth", output
     if any(marker in output for marker in test.external_failure_markers):
         return "external", output
     return "failed", output
 
 
 def main() -> int:
+    args = parse_args()
     passed: list[str] = []
+    auth: list[str] = []
     external: list[str] = []
     failed: list[tuple[str, str]] = []
 
     for test in TESTS:
-        print(f"\n=== {test.name} ===", flush=True)
         status, output = run_example(test)
         if status == "passed":
             passed.append(test.name)
-            print(color("PASS", GREEN + BOLD))
+            result = color("PASS", GREEN + BOLD)
+        elif status == "auth":
+            auth.append(test.name)
+            result = (
+                color("AUTH", ORANGE + BOLD)
+                + " - missing API key or endpoint is not authorized for this key"
+            )
         elif status == "external":
             external.append(test.name)
-            print(
-                color(
-                    "EXTERNAL",
-                    YELLOW + BOLD,
-                )
-                + ": endpoint, plan, or network prevented a live success"
+            result = (
+                color("EXTERNAL", YELLOW + BOLD)
+                + " - endpoint, plan, or network prevented a live success"
             )
         else:
             failed.append((test.name, output))
-            print(color("FAIL", RED + BOLD))
+            result = color("FAIL", RED + BOLD)
 
-        if output.strip():
-            lines = output.strip().splitlines()
-            preview = "\n".join(lines[:30])
-            if len(lines) > 30:
-                preview += f"\n... ({len(lines) - 30} more lines)"
-            print(preview)
+        print(f"{result}: {test.name}", flush=True)
+
+        should_print_output = output.strip() and (
+            args.verbose == 2 or (args.verbose == 1 and status != "passed")
+        )
+        if should_print_output:
+            print(output_preview(output))
 
     print("\n=== Summary ===")
     print(f"{color('Passed', GREEN)}   : {len(passed)}")
+    print(f"{color('Auth', ORANGE)}     : {len(auth)}")
     print(f"{color('External', YELLOW)} : {len(external)}")
     print(f"{color('Failed', RED)}   : {len(failed)}")
 
+    if auth:
+        print("\nAuth failures:")
+        for name in auth:
+            print(f"  - {name}")
+
     if external:
         print("\nExternal failures:")
         for name in external:
@@ -216,8 +275,10 @@ def main() -> int:
     if failed:
         print("\nUnexpected failures:")
         for name, output in failed:
-            print(f"\n--- {name} ---")
-            print(output.strip())
+            print(f"  - {name}")
+            if args.verbose >= 1:
+                print(f"\n--- {name} ---")
+                print(output.strip())
         return 1
 
     return 0

{helius_python-0.5.0 → helius_python-0.5.2}/tests/unit/lasterstream/test_websockets.py

@@ -64,9 +64,20 @@ def fake_ws(monkeypatch):
     """Patch `connect` so `WebSocketClient.__init__` returns a FakeWebSocket."""
     fake = FakeWebSocket()
 
-    def fake_connect(uri, proxy=None):
+    def fake_connect(
+        uri,
+        proxy=None,
+        open_timeout=None,
+        ping_interval=None,
+        ping_timeout=None,
+        close_timeout=None,
+    ):
         fake.uri = uri
         fake.proxy = proxy
+        fake.open_timeout = open_timeout
+        fake.ping_interval = ping_interval
+        fake.ping_timeout = ping_timeout
+        fake.close_timeout = close_timeout
         return fake
 
     monkeypatch.setattr(ws_module, "connect", fake_connect)
@@ -283,13 +294,29 @@ def test_init_picks_up_api_key_from_env(monkeypatch):
     monkeypatch.setenv("HELIUS_API_KEY", "from-env")
     monkeypatch.setattr(ws_module, "dotenv_values", lambda: {})
 
-    def fake_connect(uri, proxy=None):
+    def fake_connect(
+        uri,
+        proxy=None,
+        open_timeout=None,
+        ping_interval=None,
+        ping_timeout=None,
+        close_timeout=None,
+    ):
         fake.uri = uri
+        fake.proxy = proxy
+        fake.open_timeout = open_timeout
+        fake.ping_interval = ping_interval
+        fake.ping_timeout = ping_timeout
+        fake.close_timeout = close_timeout
         return fake
 
     monkeypatch.setattr(ws_module, "connect", fake_connect)
     client = WebSocketClient()
     assert "api-key=from-env" in fake.uri
+    assert fake.open_timeout == 10
+    assert fake.ping_interval == 20
+    assert fake.ping_timeout == 20
+    assert fake.close_timeout == 10
     assert client._websocket is fake
 
 
@@ -297,29 +324,67 @@ def test_init_builds_uri_with_api_key_and_passes_proxy(monkeypatch):
     fake = FakeWebSocket()
     captured = {}
 
-    def fake_connect(uri, proxy=None):
+    def fake_connect(
+        uri,
+        proxy=None,
+        open_timeout=None,
+        ping_interval=None,
+        ping_timeout=None,
+        close_timeout=None,
+    ):
         captured["uri"] = uri
         captured["proxy"] = proxy
+        captured["open_timeout"] = open_timeout
+        captured["ping_interval"] = ping_interval
+        captured["ping_timeout"] = ping_timeout
+        captured["close_timeout"] = close_timeout
         return fake
 
     monkeypatch.setattr(ws_module, "connect", fake_connect)
-    WebSocketClient(api_key="test", proxy="http://proxy:8080")
+    WebSocketClient(
+        api_key="test",
+        proxy="http://proxy:8080",
+        open_timeout=1,
+        ping_interval=2,
+        ping_timeout=3,
+        close_timeout=4,
+    )
     assert "api-key=test" in captured["uri"]
     assert captured["uri"].startswith("wss://mainnet.helius-rpc.com")
     assert captured["proxy"] == "http://proxy:8080"
+    assert captured["open_timeout"] == 1
+    assert captured["ping_interval"] == 2
+    assert captured["ping_timeout"] == 3
+    assert captured["close_timeout"] == 4
 
 
 def test_init_uses_custom_base_url(monkeypatch):
     fake = FakeWebSocket()
     captured = {}
 
-    def fake_connect(uri, proxy=None):
+    def fake_connect(
+        uri,
+        proxy=None,
+        open_timeout=None,
+        ping_interval=None,
+        ping_timeout=None,
+        close_timeout=None,
+    ):
         captured["uri"] = uri
+        captured["proxy"] = proxy
+        captured["open_timeout"] = open_timeout
+        captured["ping_interval"] = ping_interval
+        captured["ping_timeout"] = ping_timeout
+        captured["close_timeout"] = close_timeout
         return fake
 
     monkeypatch.setattr(ws_module, "connect", fake_connect)
     WebSocketClient(api_key="test", base_url="wss://devnet.helius-rpc.com")
     assert captured["uri"].startswith("wss://devnet.helius-rpc.com")
+    assert captured["open_timeout"] == 10
+    assert captured["ping_interval"] == 20
+    assert captured["ping_timeout"] == 20
+    assert captured["close_timeout"] == 10
 
 
 def test_close_delegates_to_websocket(client, fake_ws):