tradingnexus 0.1.0__tar.gz

tradingnexus-0.1.0/PKG-INFO

@@ -0,0 +1,125 @@
+Metadata-Version: 2.4
+Name: tradingnexus
+Version: 0.1.0
+Summary: Official Python client for the Trading Nexus Personal Trade API
+Author: Trading Nexus
+License: Proprietary
+Project-URL: Homepage, https://tradingnexus.pro/developers
+Project-URL: Documentation, https://tradingnexus.pro/developers
+Project-URL: Source, https://github.com/tradingnexus
+Keywords: trading,tradingnexus,algo,orders,indian-markets
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+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: Topic :: Office/Business :: Financial :: Investment
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Requires-Dist: requests>=2.28.0
+Requires-Dist: websocket-client>=1.6.0
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0; extra == "dev"
+Requires-Dist: responses>=0.25; extra == "dev"
+
+# Trading Nexus — Python client (draft)
+
+Official-style Python helper for the **Personal Trade API**  
+(own-account algo / bot access).
+
+> Status: **v0.1.0 draft** — not published to PyPI yet. Install from this folder for testing.
+
+## Install (local)
+
+```bash
+cd sdks/python
+pip install -e .
+```
+
+## Quick start
+
+```python
+from tradingnexus import TradeClient
+
+client = TradeClient(api_key="tk_your_secret_key_here")
+
+# 1) Find the exact option / equity contract
+found = client.search_instruments(
+    underlying="NIFTY",
+    exchange_segment="NSE_FNO",
+    symbol="24000",
+    limit=50,
+)
+row = next(
+    (
+        i
+        for i in found.get("instruments", [])
+        if str(i.get("option_type", "")).upper() == "PE"
+        and float(i.get("strike_price") or 0) == 24000
+    ),
+    None,
+)
+if not row:
+    raise SystemExit("Contract not found — refine search / expiry")
+
+# 2) Place order using returned fields
+order = client.place_order(
+    side="BUY",
+    quantity=int(row["lot_size"]),
+    order_type="MARKET",
+    product_type="MIS",
+    symbol=row["symbol"],
+    exchange_segment=row["exchange_segment"],
+    security_id=row.get("security_id") or row.get("instrument_token"),
+    idempotency_key="bot-demo-001",
+)
+print(order)
+```
+
+## Live order updates
+
+```python
+from tradingnexus import OrderStream
+
+def on_message(msg):
+    print(msg)
+
+stream = OrderStream(api_key="tk_your_secret_key_here", on_message=on_message)
+stream.start()
+# ... keep process alive ...
+# stream.stop()
+```
+
+## What this covers
+
+| Client method | API |
+|---------------|-----|
+| `search_instruments` / `get_instrument` | Instruments |
+| `place_order` / `modify_order` / `cancel_order` | Orders write |
+| `get_order` / `list_orders` | Orders read |
+| `list_trades` / `list_trades_for_order` | Fills |
+| `list_positions` | Positions |
+| `OrderStream` | WebSocket `/personal/ws/orders` |
+
+## Auth notes
+
+- Header: `X-PERSONAL-KEY` (server also accepts `X-API-KEY`)
+- IP allowlist is **optional per key** (Super Admin → API Access)
+- Keys are issued only by Trading Nexus Super Admin — no self-service
+
+## Docs
+
+- Web: https://tradingnexus.pro/developers  
+- Markdown: `docs/Personal_Trade_API_Reference.md`
+
+## PyPI (later)
+
+When you approve publishing:
+
+```bash
+pip install tradingnexus
+```
+
+Until then, use `pip install -e .` from `sdks/python`.

tradingnexus-0.1.0/README.md

@@ -0,0 +1,99 @@
+# Trading Nexus — Python client (draft)
+
+Official-style Python helper for the **Personal Trade API**  
+(own-account algo / bot access).
+
+> Status: **v0.1.0 draft** — not published to PyPI yet. Install from this folder for testing.
+
+## Install (local)
+
+```bash
+cd sdks/python
+pip install -e .
+```
+
+## Quick start
+
+```python
+from tradingnexus import TradeClient
+
+client = TradeClient(api_key="tk_your_secret_key_here")
+
+# 1) Find the exact option / equity contract
+found = client.search_instruments(
+    underlying="NIFTY",
+    exchange_segment="NSE_FNO",
+    symbol="24000",
+    limit=50,
+)
+row = next(
+    (
+        i
+        for i in found.get("instruments", [])
+        if str(i.get("option_type", "")).upper() == "PE"
+        and float(i.get("strike_price") or 0) == 24000
+    ),
+    None,
+)
+if not row:
+    raise SystemExit("Contract not found — refine search / expiry")
+
+# 2) Place order using returned fields
+order = client.place_order(
+    side="BUY",
+    quantity=int(row["lot_size"]),
+    order_type="MARKET",
+    product_type="MIS",
+    symbol=row["symbol"],
+    exchange_segment=row["exchange_segment"],
+    security_id=row.get("security_id") or row.get("instrument_token"),
+    idempotency_key="bot-demo-001",
+)
+print(order)
+```
+
+## Live order updates
+
+```python
+from tradingnexus import OrderStream
+
+def on_message(msg):
+    print(msg)
+
+stream = OrderStream(api_key="tk_your_secret_key_here", on_message=on_message)
+stream.start()
+# ... keep process alive ...
+# stream.stop()
+```
+
+## What this covers
+
+| Client method | API |
+|---------------|-----|
+| `search_instruments` / `get_instrument` | Instruments |
+| `place_order` / `modify_order` / `cancel_order` | Orders write |
+| `get_order` / `list_orders` | Orders read |
+| `list_trades` / `list_trades_for_order` | Fills |
+| `list_positions` | Positions |
+| `OrderStream` | WebSocket `/personal/ws/orders` |
+
+## Auth notes
+
+- Header: `X-PERSONAL-KEY` (server also accepts `X-API-KEY`)
+- IP allowlist is **optional per key** (Super Admin → API Access)
+- Keys are issued only by Trading Nexus Super Admin — no self-service
+
+## Docs
+
+- Web: https://tradingnexus.pro/developers  
+- Markdown: `docs/Personal_Trade_API_Reference.md`
+
+## PyPI (later)
+
+When you approve publishing:
+
+```bash
+pip install tradingnexus
+```
+
+Until then, use `pip install -e .` from `sdks/python`.

tradingnexus-0.1.0/pyproject.toml

@@ -0,0 +1,39 @@
+[build-system]
+requires = ["setuptools>=68", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "tradingnexus"
+version = "0.1.0"
+description = "Official Python client for the Trading Nexus Personal Trade API"
+readme = "README.md"
+requires-python = ">=3.9"
+license = { text = "Proprietary" }
+authors = [{ name = "Trading Nexus" }]
+keywords = ["trading", "tradingnexus", "algo", "orders", "indian-markets"]
+classifiers = [
+  "Development Status :: 3 - Alpha",
+  "Intended Audience :: Developers",
+  "Programming Language :: Python :: 3",
+  "Programming Language :: Python :: 3.9",
+  "Programming Language :: Python :: 3.10",
+  "Programming Language :: Python :: 3.11",
+  "Programming Language :: Python :: 3.12",
+  "Topic :: Office/Business :: Financial :: Investment",
+]
+dependencies = [
+  "requests>=2.28.0",
+  "websocket-client>=1.6.0",
+]
+
+[project.optional-dependencies]
+dev = ["pytest>=7.0", "responses>=0.25"]
+
+[project.urls]
+Homepage = "https://tradingnexus.pro/developers"
+Documentation = "https://tradingnexus.pro/developers"
+Source = "https://github.com/tradingnexus"
+
+[tool.setuptools.packages.find]
+where = ["."]
+include = ["tradingnexus*"]

tradingnexus-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

tradingnexus-0.1.0/tradingnexus/__init__.py

@@ -0,0 +1,36 @@
+"""
+Trading Nexus Personal Trade API — Python client.
+
+Install (from this folder, for local draft use):
+    pip install -e .
+
+Example:
+    from tradingnexus import TradeClient
+
+    client = TradeClient(api_key="tk_...")
+    instruments = client.search_instruments(underlying="NIFTY", exchange_segment="NSE_FNO", symbol="24000")
+"""
+
+from .client import TradeClient
+from .errors import (
+    ApiError,
+    AuthenticationError,
+    NotFoundError,
+    RateLimitError,
+    TradeApiError,
+    ValidationError,
+)
+from .websocket import OrderStream
+
+__all__ = [
+    "TradeClient",
+    "OrderStream",
+    "TradeApiError",
+    "ApiError",
+    "AuthenticationError",
+    "ValidationError",
+    "NotFoundError",
+    "RateLimitError",
+]
+
+__version__ = "0.1.0"

tradingnexus-0.1.0/tradingnexus/client.py

@@ -0,0 +1,308 @@
+"""Synchronous REST client for Trading Nexus Personal Trade API."""
+
+from __future__ import annotations
+
+from typing import Any, Dict, Mapping, Optional
+from urllib.parse import urljoin
+
+import requests
+
+from .errors import (
+    ApiError,
+    AuthenticationError,
+    NotFoundError,
+    RateLimitError,
+    TradeApiError,
+    ValidationError,
+)
+
+DEFAULT_BASE_URL = "https://api.tradingnexus.pro/api/v2"
+DEFAULT_TIMEOUT = 15.0
+
+
+class TradeClient:
+    """
+    Personal Trade API client (own account only).
+
+    Auth:
+      - Header X-PERSONAL-KEY (preferred)
+      - X-API-KEY also accepted by the server
+
+    IP restriction is configured by Super Admin per key (ON allowlist / OFF any IP).
+    """
+
+    def __init__(
+        self,
+        api_key: str,
+        *,
+        base_url: str = DEFAULT_BASE_URL,
+        timeout: float = DEFAULT_TIMEOUT,
+        session: Optional[requests.Session] = None,
+    ) -> None:
+        key = (api_key or "").strip()
+        if not key:
+            raise AuthenticationError("api_key is required")
+
+        self.api_key = key
+        self.base_url = base_url.rstrip("/") + "/"
+        self.timeout = timeout
+        self._session = session or requests.Session()
+        self._session.headers.update(
+            {
+                "X-PERSONAL-KEY": self.api_key,
+                "Accept": "application/json",
+            }
+        )
+
+    # ── Instruments ──────────────────────────────────────────────────────────
+
+    def search_instruments(
+        self,
+        *,
+        symbol: Optional[str] = None,
+        exchange_segment: Optional[str] = None,
+        underlying: Optional[str] = None,
+        offset: int = 0,
+        limit: int = 100,
+    ) -> Dict[str, Any]:
+        """GET /personal/instruments — search before placing F&O / equity orders."""
+        params: Dict[str, Any] = {"offset": offset, "limit": limit}
+        if symbol:
+            params["symbol"] = symbol
+        if exchange_segment:
+            params["exchange_segment"] = exchange_segment
+        if underlying:
+            params["underlying"] = underlying
+        return self._request("GET", "personal/instruments", params=params)
+
+    def get_instrument(self, symbol: str) -> Dict[str, Any]:
+        """GET /personal/instruments/{symbol} — exact symbol match."""
+        return self._request("GET", f"personal/instruments/{symbol}")
+
+    # ── Orders ───────────────────────────────────────────────────────────────
+
+    def place_order(
+        self,
+        *,
+        side: str,
+        quantity: int,
+        order_type: str = "MARKET",
+        product_type: str = "NORMAL",
+        symbol: Optional[str] = None,
+        exchange_segment: Optional[str] = None,
+        security_id: Optional[int] = None,
+        instrument_token: Optional[int] = None,
+        price: Optional[float] = None,
+        trigger_price: Optional[float] = None,
+        expiry_date: Optional[str] = None,
+        idempotency_key: Optional[str] = None,
+        transaction_type: Optional[str] = None,
+    ) -> Dict[str, Any]:
+        """
+        POST /personal/orders
+
+        Prefer security_id from search_instruments(). Always pass a unique
+        idempotency_key for each new order intent.
+        """
+        body: Dict[str, Any] = {
+            "side": side,
+            "quantity": quantity,
+            "order_type": order_type,
+            "product_type": product_type,
+        }
+        if transaction_type is not None:
+            body["transaction_type"] = transaction_type
+        if symbol is not None:
+            body["symbol"] = symbol
+        if exchange_segment is not None:
+            body["exchange_segment"] = exchange_segment
+        if security_id is not None:
+            body["security_id"] = security_id
+        if instrument_token is not None:
+            body["instrument_token"] = instrument_token
+        if price is not None:
+            body["price"] = price
+        if trigger_price is not None:
+            body["trigger_price"] = trigger_price
+        if expiry_date is not None:
+            body["expiry_date"] = expiry_date
+        if idempotency_key is not None:
+            body["idempotency_key"] = idempotency_key
+        return self._request("POST", "personal/orders", json=body)
+
+    def get_order(self, order_id: str) -> Dict[str, Any]:
+        """GET /personal/orders/{order_id}"""
+        return self._request("GET", f"personal/orders/{order_id}")
+
+    def list_orders(
+        self,
+        *,
+        from_date: Optional[str] = None,
+        to_date: Optional[str] = None,
+        status_filter: Optional[str] = None,
+    ) -> Dict[str, Any]:
+        """GET /personal/orders — max 500 rows."""
+        params: Dict[str, Any] = {}
+        if from_date:
+            params["from_date"] = from_date
+        if to_date:
+            params["to_date"] = to_date
+        if status_filter:
+            params["status_filter"] = status_filter
+        return self._request("GET", "personal/orders", params=params)
+
+    def modify_order(
+        self,
+        order_id: str,
+        *,
+        quantity: Optional[int] = None,
+        price: Optional[float] = None,
+        trigger_price: Optional[float] = None,
+        order_type: Optional[str] = None,
+        product_type: Optional[str] = None,
+    ) -> Dict[str, Any]:
+        """PATCH /personal/orders/{order_id}"""
+        body: Dict[str, Any] = {}
+        if quantity is not None:
+            body["quantity"] = quantity
+        if price is not None:
+            body["price"] = price
+        if trigger_price is not None:
+            body["trigger_price"] = trigger_price
+        if order_type is not None:
+            body["order_type"] = order_type
+        if product_type is not None:
+            body["product_type"] = product_type
+        if not body:
+            raise ValidationError("Provide at least one field to modify")
+        return self._request("PATCH", f"personal/orders/{order_id}", json=body)
+
+    def cancel_order(self, order_id: str) -> Dict[str, Any]:
+        """DELETE /personal/orders/{order_id}"""
+        return self._request("DELETE", f"personal/orders/{order_id}")
+
+    # ── Trades & positions ───────────────────────────────────────────────────
+
+    def list_trades(
+        self,
+        *,
+        from_date: Optional[str] = None,
+        to_date: Optional[str] = None,
+    ) -> Dict[str, Any]:
+        """GET /personal/trades"""
+        params: Dict[str, Any] = {}
+        if from_date:
+            params["from_date"] = from_date
+        if to_date:
+            params["to_date"] = to_date
+        return self._request("GET", "personal/trades", params=params)
+
+    def list_trades_for_order(self, order_id: str) -> Dict[str, Any]:
+        """GET /personal/trades/{order_id}"""
+        return self._request("GET", f"personal/trades/{order_id}")
+
+    def list_positions(self) -> Dict[str, Any]:
+        """GET /personal/positions"""
+        return self._request("GET", "personal/positions")
+
+    # ── Internals ────────────────────────────────────────────────────────────
+
+    def _request(
+        self,
+        method: str,
+        path: str,
+        *,
+        params: Optional[Mapping[str, Any]] = None,
+        json: Optional[Mapping[str, Any]] = None,
+    ) -> Dict[str, Any]:
+        url = urljoin(self.base_url, path.lstrip("/"))
+        headers = {}
+        if json is not None:
+            headers["Content-Type"] = "application/json"
+
+        try:
+            response = self._session.request(
+                method=method.upper(),
+                url=url,
+                params=params,
+                json=json,
+                headers=headers or None,
+                timeout=self.timeout,
+            )
+        except requests.RequestException as exc:
+            raise ApiError(f"Network error: {exc}") from exc
+
+        return self._parse_response(response)
+
+    def _parse_response(self, response: requests.Response) -> Dict[str, Any]:
+        status = response.status_code
+        try:
+            payload: Any = response.json() if response.content else {}
+        except ValueError:
+            payload = {"detail": response.text}
+
+        if 200 <= status < 300:
+            if isinstance(payload, dict):
+                return payload
+            return {"data": payload}
+
+        message = _extract_message(payload) or response.reason or "Request failed"
+        retry_after = None
+        if status == 429:
+            raw = response.headers.get("Retry-After")
+            if raw and str(raw).isdigit():
+                retry_after = int(raw)
+            if isinstance(payload, dict):
+                detail = payload.get("detail")
+                if isinstance(detail, dict) and detail.get("retry_after_seconds") is not None:
+                    try:
+                        retry_after = int(detail["retry_after_seconds"])
+                    except (TypeError, ValueError):
+                        pass
+            raise RateLimitError(
+                message,
+                status_code=status,
+                payload=payload,
+                retry_after_seconds=retry_after,
+            )
+
+        error_cls = _error_class_for_status(status)
+        raise error_cls(message, status_code=status, payload=payload)
+
+    def close(self) -> None:
+        self._session.close()
+
+    def __enter__(self) -> "TradeClient":
+        return self
+
+    def __exit__(self, exc_type, exc, tb) -> None:
+        self.close()
+
+
+def _extract_message(payload: Any) -> str:
+    if payload is None:
+        return ""
+    if isinstance(payload, str):
+        return payload
+    if isinstance(payload, dict):
+        detail = payload.get("detail", payload.get("message", payload.get("error")))
+        if isinstance(detail, str):
+            return detail
+        if isinstance(detail, dict):
+            return str(detail.get("message") or detail.get("error") or detail)
+        if detail is not None:
+            return str(detail)
+        return str(payload)
+    return str(payload)
+
+
+def _error_class_for_status(status: int) -> type[TradeApiError]:
+    if status in (401, 403):
+        return AuthenticationError
+    if status == 404:
+        return NotFoundError
+    if status == 400 or status == 409:
+        return ValidationError
+    if status == 429:
+        return RateLimitError
+    return ApiError

tradingnexus-0.1.0/tradingnexus/errors.py

@@ -0,0 +1,57 @@
+"""Exceptions for the Trading Nexus Personal Trade API client."""
+
+from __future__ import annotations
+
+from typing import Any, Optional
+
+
+class TradeApiError(Exception):
+    """Base error for all Trading Nexus client failures."""
+
+    def __init__(
+        self,
+        message: str,
+        *,
+        status_code: Optional[int] = None,
+        payload: Any = None,
+    ) -> None:
+        super().__init__(message)
+        self.message = message
+        self.status_code = status_code
+        self.payload = payload
+
+    def __str__(self) -> str:
+        if self.status_code is None:
+            return self.message
+        return f"[{self.status_code}] {self.message}"
+
+
+class AuthenticationError(TradeApiError):
+    """Missing / invalid / revoked API key, or IP not allowed when restriction is ON."""
+
+
+class ValidationError(TradeApiError):
+    """Bad request input (lot size, price, missing fields, etc.)."""
+
+
+class NotFoundError(TradeApiError):
+    """Order / instrument / resource not found for this account."""
+
+
+class RateLimitError(TradeApiError):
+    """HTTP 429 — slow down; honour retry_after_seconds when present."""
+
+    def __init__(
+        self,
+        message: str,
+        *,
+        status_code: int = 429,
+        payload: Any = None,
+        retry_after_seconds: Optional[int] = None,
+    ) -> None:
+        super().__init__(message, status_code=status_code, payload=payload)
+        self.retry_after_seconds = retry_after_seconds
+
+
+class ApiError(TradeApiError):
+    """Unexpected API / network failure."""

tradingnexus-0.1.0/tradingnexus/websocket.py

@@ -0,0 +1,130 @@
+"""WebSocket helper for live Personal Trade API order / fill updates."""
+
+from __future__ import annotations
+
+import json
+import threading
+from typing import Any, Callable, Dict, Optional
+from urllib.parse import urlencode
+
+from .errors import AuthenticationError, TradeApiError
+
+try:
+    import websocket
+except ImportError as exc:  # pragma: no cover
+    raise ImportError(
+        "websocket-client is required for OrderStream. Install with: pip install websocket-client"
+    ) from exc
+
+MessageHandler = Callable[[Dict[str, Any]], None]
+ErrorHandler = Callable[[Exception], None]
+
+DEFAULT_WS_BASE = "wss://api.tradingnexus.pro/api/v2/personal/ws/orders"
+
+
+class OrderStream:
+    """
+    Live order + trade updates for the key owner's account.
+
+    Example:
+        def on_message(msg):
+            print(msg)
+
+        stream = OrderStream(api_key="tk_...", on_message=on_message)
+        stream.start()
+        ...
+        stream.stop()
+    """
+
+    def __init__(
+        self,
+        api_key: str,
+        *,
+        ws_url: str = DEFAULT_WS_BASE,
+        on_message: Optional[MessageHandler] = None,
+        on_error: Optional[ErrorHandler] = None,
+        on_open: Optional[Callable[[], None]] = None,
+        on_close: Optional[Callable[[], None]] = None,
+    ) -> None:
+        key = (api_key or "").strip()
+        if not key:
+            raise AuthenticationError("api_key is required")
+
+        self.api_key = key
+        query = urlencode({"api_key": self.api_key})
+        sep = "&" if "?" in ws_url else "?"
+        self.ws_url = f"{ws_url}{sep}{query}"
+        self.on_message = on_message
+        self.on_error = on_error
+        self.on_open = on_open
+        self.on_close = on_close
+
+        self._ws: Optional[websocket.WebSocketApp] = None
+        self._thread: Optional[threading.Thread] = None
+        self._running = False
+
+    def start(self, *, ping_interval: int = 20, ping_timeout: int = 10) -> None:
+        if self._running:
+            return
+
+        def _on_message(_ws, message: str) -> None:
+            try:
+                payload = json.loads(message)
+            except json.JSONDecodeError:
+                payload = {"type": "raw", "data": message}
+            if self.on_message:
+                self.on_message(payload)
+
+        def _on_error(_ws, error: Any) -> None:
+            exc = error if isinstance(error, Exception) else TradeApiError(str(error))
+            if self.on_error:
+                self.on_error(exc)
+
+        def _on_open(_ws) -> None:
+            if self.on_open:
+                self.on_open()
+
+        def _on_close(_ws, _status_code, _msg) -> None:
+            self._running = False
+            if self.on_close:
+                self.on_close()
+
+        self._ws = websocket.WebSocketApp(
+            self.ws_url,
+            header=[f"X-PERSONAL-KEY: {self.api_key}"],
+            on_message=_on_message,
+            on_error=_on_error,
+            on_open=_on_open,
+            on_close=_on_close,
+        )
+        self._running = True
+        self._thread = threading.Thread(
+            target=self._ws.run_forever,
+            kwargs={"ping_interval": ping_interval, "ping_timeout": ping_timeout},
+            name="tradingnexus-order-stream",
+            daemon=True,
+        )
+        self._thread.start()
+
+    def stop(self) -> None:
+        self._running = False
+        if self._ws is not None:
+            try:
+                self._ws.close()
+            except Exception:
+                pass
+        if self._thread is not None and self._thread.is_alive():
+            self._thread.join(timeout=5)
+        self._thread = None
+        self._ws = None
+
+    @property
+    def is_running(self) -> bool:
+        return self._running
+
+    def __enter__(self) -> "OrderStream":
+        self.start()
+        return self
+
+    def __exit__(self, exc_type, exc, tb) -> None:
+        self.stop()

tradingnexus-0.1.0/tradingnexus.egg-info/PKG-INFO

@@ -0,0 +1,125 @@
+Metadata-Version: 2.4
+Name: tradingnexus
+Version: 0.1.0
+Summary: Official Python client for the Trading Nexus Personal Trade API
+Author: Trading Nexus
+License: Proprietary
+Project-URL: Homepage, https://tradingnexus.pro/developers
+Project-URL: Documentation, https://tradingnexus.pro/developers
+Project-URL: Source, https://github.com/tradingnexus
+Keywords: trading,tradingnexus,algo,orders,indian-markets
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+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: Topic :: Office/Business :: Financial :: Investment
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Requires-Dist: requests>=2.28.0
+Requires-Dist: websocket-client>=1.6.0
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0; extra == "dev"
+Requires-Dist: responses>=0.25; extra == "dev"
+
+# Trading Nexus — Python client (draft)
+
+Official-style Python helper for the **Personal Trade API**  
+(own-account algo / bot access).
+
+> Status: **v0.1.0 draft** — not published to PyPI yet. Install from this folder for testing.
+
+## Install (local)
+
+```bash
+cd sdks/python
+pip install -e .
+```
+
+## Quick start
+
+```python
+from tradingnexus import TradeClient
+
+client = TradeClient(api_key="tk_your_secret_key_here")
+
+# 1) Find the exact option / equity contract
+found = client.search_instruments(
+    underlying="NIFTY",
+    exchange_segment="NSE_FNO",
+    symbol="24000",
+    limit=50,
+)
+row = next(
+    (
+        i
+        for i in found.get("instruments", [])
+        if str(i.get("option_type", "")).upper() == "PE"
+        and float(i.get("strike_price") or 0) == 24000
+    ),
+    None,
+)
+if not row:
+    raise SystemExit("Contract not found — refine search / expiry")
+
+# 2) Place order using returned fields
+order = client.place_order(
+    side="BUY",
+    quantity=int(row["lot_size"]),
+    order_type="MARKET",
+    product_type="MIS",
+    symbol=row["symbol"],
+    exchange_segment=row["exchange_segment"],
+    security_id=row.get("security_id") or row.get("instrument_token"),
+    idempotency_key="bot-demo-001",
+)
+print(order)
+```
+
+## Live order updates
+
+```python
+from tradingnexus import OrderStream
+
+def on_message(msg):
+    print(msg)
+
+stream = OrderStream(api_key="tk_your_secret_key_here", on_message=on_message)
+stream.start()
+# ... keep process alive ...
+# stream.stop()
+```
+
+## What this covers
+
+| Client method | API |
+|---------------|-----|
+| `search_instruments` / `get_instrument` | Instruments |
+| `place_order` / `modify_order` / `cancel_order` | Orders write |
+| `get_order` / `list_orders` | Orders read |
+| `list_trades` / `list_trades_for_order` | Fills |
+| `list_positions` | Positions |
+| `OrderStream` | WebSocket `/personal/ws/orders` |
+
+## Auth notes
+
+- Header: `X-PERSONAL-KEY` (server also accepts `X-API-KEY`)
+- IP allowlist is **optional per key** (Super Admin → API Access)
+- Keys are issued only by Trading Nexus Super Admin — no self-service
+
+## Docs
+
+- Web: https://tradingnexus.pro/developers  
+- Markdown: `docs/Personal_Trade_API_Reference.md`
+
+## PyPI (later)
+
+When you approve publishing:
+
+```bash
+pip install tradingnexus
+```
+
+Until then, use `pip install -e .` from `sdks/python`.

tradingnexus-0.1.0/tradingnexus.egg-info/SOURCES.txt

@@ -0,0 +1,11 @@
+README.md
+pyproject.toml
+tradingnexus/__init__.py
+tradingnexus/client.py
+tradingnexus/errors.py
+tradingnexus/websocket.py
+tradingnexus.egg-info/PKG-INFO
+tradingnexus.egg-info/SOURCES.txt
+tradingnexus.egg-info/dependency_links.txt
+tradingnexus.egg-info/requires.txt
+tradingnexus.egg-info/top_level.txt

tradingnexus-0.1.0/tradingnexus.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

tradingnexus-0.1.0/tradingnexus.egg-info/requires.txt

@@ -0,0 +1,6 @@
+requests>=2.28.0
+websocket-client>=1.6.0
+
+[dev]
+pytest>=7.0
+responses>=0.25

tradingnexus-0.1.0/tradingnexus.egg-info/top_level.txt

@@ -0,0 +1 @@
+tradingnexus