lse-data 0.1.0__tar.gz

lse_data-0.1.0/.gitignore

@@ -0,0 +1,4 @@
+__pycache__/
+*.pyc
+dist/
+*.egg-info/

lse_data-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 London Strategic Edge
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+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.

lse_data-0.1.0/PKG-INFO

@@ -0,0 +1,178 @@
+Metadata-Version: 2.4
+Name: lse-data
+Version: 0.1.0
+Summary: Python SDK for London Strategic Edge real-time market data
+Project-URL: Homepage, https://londonstrategicedge.com
+Project-URL: Documentation, https://github.com/londonstrategicedge/lse-data
+Project-URL: Repository, https://github.com/londonstrategicedge/lse-data
+Project-URL: Issues, https://github.com/londonstrategicedge/lse-data/issues
+Author-email: London Strategic Edge <support@londonstrategicedge.com>
+License-Expression: MIT
+License-File: LICENSE
+Keywords: crypto,forex,market-data,options,real-time,stocks,trading,websocket
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Financial and Insurance Industry
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Office/Business :: Financial :: Investment
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.8
+Requires-Dist: websockets>=11.0
+Provides-Extra: pandas
+Requires-Dist: pandas>=1.5; extra == 'pandas'
+Description-Content-Type: text/markdown
+
+# lse-data
+
+Python SDK for [London Strategic Edge](https://londonstrategicedge.com) real-time market data.
+
+Stream live prices for **2,000+ instruments** including stocks, crypto, forex, indices, commodities, ETFs, and options.
+
+## Install
+
+```bash
+pip install lse-data
+```
+
+## Quick start
+
+```python
+from lse import LSE
+
+client = LSE(api_key="your_api_key")
+
+for tick in client.stream(["BTC/USD", "AAPL", "EUR/USD"]):
+    print(f"{tick.symbol}: ${tick.price}")
+```
+
+Get your API key at [londonstrategicedge.com/data](https://londonstrategicedge.com/data).
+
+## Features
+
+- Real-time WebSocket streaming with auto-reconnect
+- 2,000+ symbols: US/UK/EU/Asia stocks, crypto, forex, indices, commodities, options
+- Sync and async interfaces
+- Callback and iterator patterns
+- Zero config, just an API key
+
+## Usage
+
+### Stream ticks (simplest)
+
+```python
+from lse import LSE
+
+client = LSE(api_key="your_key")
+
+for tick in client.stream(["BTC/USD", "ETH/USD", "AAPL"]):
+    print(f"{tick.symbol:12s} ${tick.price:>12,.2f}")
+```
+
+### Callback style
+
+```python
+from lse import LSE
+
+def on_tick(tick):
+    print(f"{tick.symbol}: {tick.price}")
+
+client = LSE(api_key="your_key")
+client.on("tick", on_tick)
+client.connect(symbols=["BTC/USD", "ETH/USD"])
+```
+
+### Async streaming
+
+```python
+import asyncio
+from lse import LSE
+
+async def main():
+    client = LSE(api_key="your_key")
+    async for tick in client.stream_async(["BTC/USD"]):
+        print(tick)
+
+asyncio.run(main())
+```
+
+### Save to CSV
+
+```python
+import csv, datetime
+from lse import LSE
+
+client = LSE(api_key="your_key")
+
+with open("ticks.csv", "w", newline="") as f:
+    writer = csv.writer(f)
+    writer.writerow(["time", "symbol", "price", "bid", "ask"])
+
+    for tick in client.stream(["BTC/USD", "ETH/USD"]):
+        writer.writerow([
+            datetime.datetime.now().isoformat(),
+            tick.symbol, tick.price, tick.bid, tick.ask,
+        ])
+```
+
+## Tick object
+
+Each tick has these fields:
+
+| Field | Type | Description |
+|-------|------|-------------|
+| `symbol` | `str` | Instrument symbol (e.g. `BTC/USD`, `AAPL`) |
+| `price` | `float` | Latest price |
+| `bid` | `float` | Bid price (if available) |
+| `ask` | `float` | Ask price (if available) |
+| `volume` | `float` | Volume (if available) |
+| `timestamp` | `float` | Unix timestamp |
+| `name` | `str` | Human-readable name (e.g. `Apple Inc.`) |
+
+## Events
+
+When using the callback style with `.on()`:
+
+| Event | Callback args | Description |
+|-------|---------------|-------------|
+| `tick` | `Tick` | New price tick |
+| `connected` | (none) | WebSocket connected |
+| `authenticated` | (none) | API key accepted |
+| `disconnected` | (none) | Connection lost (will auto-reconnect) |
+| `error` | `str` | Error message |
+
+## Available symbols
+
+After connecting, `client.symbols` contains the full list of available instruments:
+
+```python
+client = LSE(api_key="your_key")
+
+# stream() handles connection internally, but you can also connect manually:
+import asyncio, json, websockets
+
+async def list_symbols():
+    async with websockets.connect("wss://data-ws.londonstrategicedge.com") as ws:
+        await ws.recv()  # welcome
+        await ws.send(json.dumps({"action": "auth", "api_key": "your_key"}))
+        data = json.loads(await ws.recv())
+        for s in data["symbols"]:
+            print(s["symbol"], s.get("name", ""))
+
+asyncio.run(list_symbols())
+```
+
+## Requirements
+
+- Python 3.8+
+- `websockets` (installed automatically)
+
+## License
+
+MIT

lse_data-0.1.0/README.md

@@ -0,0 +1,147 @@
+# lse-data
+
+Python SDK for [London Strategic Edge](https://londonstrategicedge.com) real-time market data.
+
+Stream live prices for **2,000+ instruments** including stocks, crypto, forex, indices, commodities, ETFs, and options.
+
+## Install
+
+```bash
+pip install lse-data
+```
+
+## Quick start
+
+```python
+from lse import LSE
+
+client = LSE(api_key="your_api_key")
+
+for tick in client.stream(["BTC/USD", "AAPL", "EUR/USD"]):
+    print(f"{tick.symbol}: ${tick.price}")
+```
+
+Get your API key at [londonstrategicedge.com/data](https://londonstrategicedge.com/data).
+
+## Features
+
+- Real-time WebSocket streaming with auto-reconnect
+- 2,000+ symbols: US/UK/EU/Asia stocks, crypto, forex, indices, commodities, options
+- Sync and async interfaces
+- Callback and iterator patterns
+- Zero config, just an API key
+
+## Usage
+
+### Stream ticks (simplest)
+
+```python
+from lse import LSE
+
+client = LSE(api_key="your_key")
+
+for tick in client.stream(["BTC/USD", "ETH/USD", "AAPL"]):
+    print(f"{tick.symbol:12s} ${tick.price:>12,.2f}")
+```
+
+### Callback style
+
+```python
+from lse import LSE
+
+def on_tick(tick):
+    print(f"{tick.symbol}: {tick.price}")
+
+client = LSE(api_key="your_key")
+client.on("tick", on_tick)
+client.connect(symbols=["BTC/USD", "ETH/USD"])
+```
+
+### Async streaming
+
+```python
+import asyncio
+from lse import LSE
+
+async def main():
+    client = LSE(api_key="your_key")
+    async for tick in client.stream_async(["BTC/USD"]):
+        print(tick)
+
+asyncio.run(main())
+```
+
+### Save to CSV
+
+```python
+import csv, datetime
+from lse import LSE
+
+client = LSE(api_key="your_key")
+
+with open("ticks.csv", "w", newline="") as f:
+    writer = csv.writer(f)
+    writer.writerow(["time", "symbol", "price", "bid", "ask"])
+
+    for tick in client.stream(["BTC/USD", "ETH/USD"]):
+        writer.writerow([
+            datetime.datetime.now().isoformat(),
+            tick.symbol, tick.price, tick.bid, tick.ask,
+        ])
+```
+
+## Tick object
+
+Each tick has these fields:
+
+| Field | Type | Description |
+|-------|------|-------------|
+| `symbol` | `str` | Instrument symbol (e.g. `BTC/USD`, `AAPL`) |
+| `price` | `float` | Latest price |
+| `bid` | `float` | Bid price (if available) |
+| `ask` | `float` | Ask price (if available) |
+| `volume` | `float` | Volume (if available) |
+| `timestamp` | `float` | Unix timestamp |
+| `name` | `str` | Human-readable name (e.g. `Apple Inc.`) |
+
+## Events
+
+When using the callback style with `.on()`:
+
+| Event | Callback args | Description |
+|-------|---------------|-------------|
+| `tick` | `Tick` | New price tick |
+| `connected` | (none) | WebSocket connected |
+| `authenticated` | (none) | API key accepted |
+| `disconnected` | (none) | Connection lost (will auto-reconnect) |
+| `error` | `str` | Error message |
+
+## Available symbols
+
+After connecting, `client.symbols` contains the full list of available instruments:
+
+```python
+client = LSE(api_key="your_key")
+
+# stream() handles connection internally, but you can also connect manually:
+import asyncio, json, websockets
+
+async def list_symbols():
+    async with websockets.connect("wss://data-ws.londonstrategicedge.com") as ws:
+        await ws.recv()  # welcome
+        await ws.send(json.dumps({"action": "auth", "api_key": "your_key"}))
+        data = json.loads(await ws.recv())
+        for s in data["symbols"]:
+            print(s["symbol"], s.get("name", ""))
+
+asyncio.run(list_symbols())
+```
+
+## Requirements
+
+- Python 3.8+
+- `websockets` (installed automatically)
+
+## License
+
+MIT

lse_data-0.1.0/examples/async_stream.py

@@ -0,0 +1,20 @@
+"""
+Async streaming example - for use in async applications.
+
+Usage:
+    pip install lse-data
+    python async_stream.py
+"""
+
+import asyncio
+from lse import LSE
+
+
+async def main():
+    client = LSE(api_key="YOUR_API_KEY")
+
+    async for tick in client.stream_async(["BTC/USD", "AAPL", "EUR/USD"]):
+        print(f"{tick.symbol:12s} {tick.price:>12,.2f}  {tick.name or ''}")
+
+
+asyncio.run(main())

lse_data-0.1.0/examples/basic_stream.py

@@ -0,0 +1,14 @@
+"""
+Basic streaming example - print live prices to the terminal.
+
+Usage:
+    pip install lse-data
+    python basic_stream.py
+"""
+
+from lse import LSE
+
+client = LSE(api_key="YOUR_API_KEY")
+
+for tick in client.stream(["BTC/USD", "ETH/USD", "AAPL", "EUR/USD"]):
+    print(f"{tick.symbol:12s} ${tick.price:>12,.2f}")

lse_data-0.1.0/examples/callback_style.py

@@ -0,0 +1,35 @@
+"""
+Callback-style example - event-driven tick handling.
+
+Usage:
+    pip install lse-data
+    python callback_style.py
+"""
+
+from lse import LSE
+
+
+def on_tick(tick):
+    print(f"[TICK] {tick.symbol}: {tick.price}")
+
+
+def on_connected():
+    print("Connected to LSE")
+
+
+def on_authenticated():
+    print("Authenticated successfully")
+
+
+def on_error(msg):
+    print(f"[ERROR] {msg}")
+
+
+client = LSE(api_key="YOUR_API_KEY")
+client.on("tick", on_tick)
+client.on("connected", on_connected)
+client.on("authenticated", on_authenticated)
+client.on("error", on_error)
+
+# connect() blocks forever, ticks arrive via on_tick callback
+client.connect(symbols=["BTC/USD", "ETH/USD", "SOL/USD"])

lse_data-0.1.0/examples/save_to_csv.py

@@ -0,0 +1,23 @@
+"""
+Save live ticks to a CSV file.
+
+Usage:
+    pip install lse-data
+    python save_to_csv.py
+"""
+
+import csv
+import datetime
+from lse import LSE
+
+client = LSE(api_key="YOUR_API_KEY")
+
+with open("ticks.csv", "w", newline="") as f:
+    writer = csv.writer(f)
+    writer.writerow(["timestamp", "symbol", "price", "bid", "ask"])
+
+    for tick in client.stream(["BTC/USD", "ETH/USD"]):
+        now = datetime.datetime.now().isoformat()
+        writer.writerow([now, tick.symbol, tick.price, tick.bid, tick.ask])
+        f.flush()  # write immediately so you can tail the file
+        print(f"{now} {tick.symbol} {tick.price}")

lse_data-0.1.0/lse/__init__.py

@@ -0,0 +1,21 @@
+"""
+London Strategic Edge - Python SDK for real-time market data.
+
+Usage:
+    from lse import LSE
+
+    client = LSE(api_key="your_api_key")
+
+    # Stream live ticks
+    for tick in client.stream(["BTC/USD", "AAPL", "EUR/USD"]):
+        print(f"{tick.symbol} {tick.price}")
+
+    # Async streaming
+    async for tick in client.stream_async(["BTC/USD"]):
+        print(tick)
+"""
+
+from lse.client import LSE, Tick
+
+__version__ = "0.1.0"
+__all__ = ["LSE", "Tick"]

lse_data-0.1.0/lse/client.py

@@ -0,0 +1,360 @@
+"""
+LSE WebSocket client for real-time market data streaming.
+
+Connects to wss://data-ws.londonstrategicedge.com and provides a clean
+interface for subscribing to symbols and receiving live price ticks.
+"""
+
+import asyncio
+import json
+import threading
+import time
+from dataclasses import dataclass, field
+from typing import Callable, Dict, Iterator, List, Optional, Set
+
+import websockets
+import websockets.client
+
+
+WS_URL = "wss://data-ws.londonstrategicedge.com"
+
+# Ping interval to keep the connection alive. The server expects a ping
+# within its idle timeout window (currently 600s). We send every 25s to
+# stay well under the server's 30s protocol-level ping interval.
+PING_INTERVAL = 25
+
+
+@dataclass
+class Tick:
+    """A single price tick from the LSE feed."""
+    symbol: str
+    price: float
+    bid: Optional[float] = None
+    ask: Optional[float] = None
+    volume: Optional[float] = None
+    timestamp: Optional[float] = None
+    name: Optional[str] = None
+
+    def __repr__(self) -> str:
+        return f"Tick({self.symbol} {self.price})"
+
+
+class LSE:
+    """Client for London Strategic Edge real-time market data.
+
+    Args:
+        api_key: Your LSE API key. Get one at https://londonstrategicedge.com/data
+        url: WebSocket endpoint. Defaults to the production server.
+
+    Examples:
+        Synchronous streaming (simplest):
+
+            from lse import LSE
+
+            client = LSE(api_key="your_key")
+            for tick in client.stream(["BTC/USD", "AAPL"]):
+                print(tick.symbol, tick.price)
+
+        With a callback:
+
+            def on_tick(tick):
+                print(f"{tick.symbol}: {tick.price}")
+
+            client = LSE(api_key="your_key")
+            client.on("tick", on_tick)
+            client.subscribe(["BTC/USD", "ETH/USD"])
+            client.connect()  # blocks forever
+
+        Async streaming:
+
+            import asyncio
+            from lse import LSE
+
+            async def main():
+                client = LSE(api_key="your_key")
+                async for tick in client.stream_async(["BTC/USD"]):
+                    print(tick)
+
+            asyncio.run(main())
+    """
+
+    def __init__(self, api_key: str, url: str = WS_URL):
+        self._api_key = api_key
+        self._url = url
+        self._ws: Optional[websockets.client.WebSocketClientProtocol] = None
+        self._callbacks: Dict[str, List[Callable]] = {}
+        self._symbols: List[dict] = []
+        self._tier: str = ""
+        self._authenticated = False
+        self._subscriptions: Set[str] = set()
+
+    # ------------------------------------------------------------------
+    # Public properties
+    # ------------------------------------------------------------------
+
+    @property
+    def symbols(self) -> List[dict]:
+        """List of available symbols returned after authentication."""
+        return self._symbols
+
+    @property
+    def tier(self) -> str:
+        """Account tier (e.g. 'basic', 'pro')."""
+        return self._tier
+
+    @property
+    def authenticated(self) -> bool:
+        """Whether the client has successfully authenticated."""
+        return self._authenticated
+
+    @property
+    def subscriptions(self) -> Set[str]:
+        """Set of currently subscribed symbols."""
+        return self._subscriptions.copy()
+
+    # ------------------------------------------------------------------
+    # Event callbacks
+    # ------------------------------------------------------------------
+
+    def on(self, event: str, callback: Callable) -> "LSE":
+        """Register a callback for an event.
+
+        Supported events:
+            - "tick": called with a Tick object on each price update
+            - "connected": called when WebSocket connects
+            - "authenticated": called when auth succeeds
+            - "disconnected": called when connection drops
+            - "error": called with error message string
+
+        Args:
+            event: Event name.
+            callback: Function to call.
+
+        Returns:
+            self, for chaining.
+        """
+        self._callbacks.setdefault(event, []).append(callback)
+        return self
+
+    def _emit(self, event: str, *args):
+        for cb in self._callbacks.get(event, []):
+            try:
+                cb(*args)
+            except Exception:
+                pass
+
+    # ------------------------------------------------------------------
+    # Synchronous API (blocking)
+    # ------------------------------------------------------------------
+
+    def stream(self, symbols: List[str], reconnect: bool = True) -> Iterator[Tick]:
+        """Stream live ticks. Blocks forever, yields Tick objects.
+
+        This is the simplest way to consume live data. It handles connection,
+        authentication, subscription, ping/pong, and auto-reconnect internally.
+
+        Args:
+            symbols: List of symbols to subscribe to (e.g. ["BTC/USD", "AAPL"]).
+            reconnect: If True, automatically reconnect on disconnect.
+
+        Yields:
+            Tick objects as they arrive.
+
+        Example:
+            from lse import LSE
+
+            client = LSE(api_key="your_key")
+            for tick in client.stream(["BTC/USD", "ETH/USD", "AAPL"]):
+                print(f"{tick.symbol}: ${tick.price}")
+        """
+        while True:
+            try:
+                # Run the async generator in a new event loop.
+                # We suppress "task was destroyed" warnings that occur when
+                # the caller breaks out of the iterator mid-stream, which is
+                # normal usage (e.g. "for tick in stream: if done: break").
+                import warnings
+                loop = asyncio.new_event_loop()
+                try:
+                    gen = self.stream_async(symbols, reconnect=False).__aiter__()
+                    while True:
+                        tick = loop.run_until_complete(gen.__anext__())
+                        yield tick
+                except StopAsyncIteration:
+                    pass
+                except GeneratorExit:
+                    return
+                finally:
+                    # Shut down pending tasks cleanly to avoid warnings
+                    pending = asyncio.all_tasks(loop)
+                    for task in pending:
+                        task.cancel()
+                    if pending:
+                        with warnings.catch_warnings():
+                            warnings.simplefilter("ignore")
+                            loop.run_until_complete(asyncio.gather(*pending, return_exceptions=True))
+                    loop.close()
+            except Exception as e:
+                self._emit("error", str(e))
+                if not reconnect:
+                    raise
+                time.sleep(3)
+
+    def connect(self, symbols: Optional[List[str]] = None):
+        """Connect and block forever, dispatching events via callbacks.
+
+        Use this with .on("tick", callback) for event-driven usage.
+        For iterator-style usage, use .stream() instead.
+
+        Args:
+            symbols: Optional list of symbols to subscribe to on connect.
+                     You can also call .subscribe() separately.
+        """
+        asyncio.run(self._run_forever(symbols or []))
+
+    def subscribe(self, symbols: List[str]):
+        """Subscribe to additional symbols (only works during .connect()).
+
+        For most use cases, pass symbols directly to .stream() or .connect().
+        """
+        for sym in symbols:
+            self._subscriptions.add(sym)
+            if self._ws:
+                asyncio.get_event_loop().run_until_complete(
+                    self._ws.send(json.dumps({"action": "subscribe", "symbol": sym}))
+                )
+
+    # ------------------------------------------------------------------
+    # Async API
+    # ------------------------------------------------------------------
+
+    async def stream_async(self, symbols: List[str], reconnect: bool = True):
+        """Async generator that yields Tick objects.
+
+        Args:
+            symbols: List of symbols to subscribe to.
+            reconnect: If True, automatically reconnect on disconnect.
+
+        Yields:
+            Tick objects as they arrive.
+
+        Example:
+            import asyncio
+            from lse import LSE
+
+            async def main():
+                client = LSE(api_key="your_key")
+                async for tick in client.stream_async(["BTC/USD"]):
+                    print(tick)
+
+            asyncio.run(main())
+        """
+        while True:
+            try:
+                async for tick in self._stream_once(symbols):
+                    yield tick
+            except Exception as e:
+                self._emit("error", str(e))
+                self._emit("disconnected")
+                if not reconnect:
+                    return
+                await asyncio.sleep(3)
+
+    async def connect_async(self, symbols: Optional[List[str]] = None):
+        """Async version of connect(). Blocks forever."""
+        await self._run_forever(symbols or [])
+
+    # ------------------------------------------------------------------
+    # Internal
+    # ------------------------------------------------------------------
+
+    async def _stream_once(self, symbols: List[str]):
+        """Single connection session. Yields ticks until disconnect."""
+        async with websockets.connect(
+            self._url,
+            ping_interval=PING_INTERVAL,
+            ping_timeout=30,
+        ) as ws:
+            self._ws = ws
+            self._authenticated = False
+
+            # Wait for welcome
+            raw = await ws.recv()
+            msg = json.loads(raw)
+            if msg.get("type") == "welcome":
+                self._emit("connected")
+
+            # Authenticate
+            await ws.send(json.dumps({
+                "action": "auth",
+                "api_key": self._api_key,
+            }))
+
+            # Start keepalive pings in background
+            ping_task = asyncio.create_task(self._ping_loop(ws))
+
+            try:
+                async for raw in ws:
+                    msg = json.loads(raw)
+                    msg_type = msg.get("type")
+
+                    if msg_type == "authenticated":
+                        self._authenticated = True
+                        self._tier = msg.get("tier", "")
+                        self._symbols = msg.get("symbols", [])
+                        self._emit("authenticated")
+
+                        # Subscribe to requested symbols
+                        for sym in symbols:
+                            self._subscriptions.add(sym)
+                            await ws.send(json.dumps({
+                                "action": "subscribe",
+                                "symbol": sym,
+                            }))
+
+                    elif msg_type == "tick":
+                        tick = Tick(
+                            symbol=msg.get("symbol", ""),
+                            price=msg.get("price", 0.0),
+                            bid=msg.get("bid"),
+                            ask=msg.get("ask"),
+                            volume=msg.get("volume"),
+                            timestamp=msg.get("ts"),
+                            name=msg.get("name"),
+                        )
+                        self._emit("tick", tick)
+                        yield tick
+
+                    elif msg_type == "error":
+                        self._emit("error", msg.get("message", "Unknown error"))
+
+                    elif msg_type == "pong":
+                        pass  # keepalive response, ignore
+
+            finally:
+                ping_task.cancel()
+                self._ws = None
+                self._authenticated = False
+
+    async def _run_forever(self, symbols: List[str]):
+        """Connect, subscribe, and dispatch events forever with auto-reconnect."""
+        while True:
+            try:
+                async for tick in self._stream_once(symbols):
+                    pass  # ticks dispatched via callbacks in _stream_once
+            except Exception as e:
+                self._emit("error", str(e))
+                self._emit("disconnected")
+                await asyncio.sleep(3)
+
+    async def _ping_loop(self, ws):
+        """Send application-level pings to keep the connection alive."""
+        try:
+            while True:
+                await asyncio.sleep(PING_INTERVAL)
+                try:
+                    await ws.send(json.dumps({"action": "ping"}))
+                except Exception:
+                    break
+        except asyncio.CancelledError:
+            pass

lse_data-0.1.0/pyproject.toml

@@ -0,0 +1,45 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "lse-data"
+version = "0.1.0"
+description = "Python SDK for London Strategic Edge real-time market data"
+readme = "README.md"
+license = "MIT"
+requires-python = ">=3.8"
+authors = [
+    { name = "London Strategic Edge", email = "support@londonstrategicedge.com" },
+]
+keywords = ["trading", "market-data", "websocket", "stocks", "crypto", "forex", "options", "real-time"]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Developers",
+    "Intended Audience :: Financial and Insurance Industry",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.8",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Topic :: Office/Business :: Financial :: Investment",
+    "Topic :: Software Development :: Libraries :: Python Modules",
+]
+dependencies = [
+    "websockets>=11.0",
+]
+
+[project.optional-dependencies]
+pandas = ["pandas>=1.5"]
+
+[tool.hatch.build.targets.wheel]
+packages = ["lse"]
+
+[project.urls]
+Homepage = "https://londonstrategicedge.com"
+Documentation = "https://github.com/londonstrategicedge/lse-data"
+Repository = "https://github.com/londonstrategicedge/lse-data"
+Issues = "https://github.com/londonstrategicedge/lse-data/issues"