kitecli 0.1.0b1__tar.gz

kitecli-0.1.0b1/PKG-INFO

@@ -0,0 +1,158 @@
+Metadata-Version: 2.4
+Name: kitecli
+Version: 0.1.0b1
+Summary: Kite Connect CLI — Multi-account Zerodha trading positions viewer
+Author: KiteCLI Team
+License: MIT
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: typer>=0.9.0
+Requires-Dist: rich>=13.0.0
+Requires-Dist: pyyaml>=6.0.0
+Requires-Dist: prompt_toolkit>=3.0.36
+Requires-Dist: kiteconnect>=5.0.0
+Requires-Dist: pyotp>=2.9.0
+Requires-Dist: requests>=2.31.0
+Requires-Dist: yfinance>=0.2.0
+Provides-Extra: server
+Requires-Dist: fastapi>=0.110.0; extra == "server"
+Requires-Dist: uvicorn[standard]>=0.27.0; extra == "server"
+Requires-Dist: pydantic>=2.0.0; extra == "server"
+Provides-Extra: dev
+Requires-Dist: pytest>=8.0.0; extra == "dev"
+Requires-Dist: pytest-asyncio>=0.23.0; extra == "dev"
+Requires-Dist: httpx>=0.27.0; extra == "dev"
+
+# KCLI — Kite Connect CLI
+
+A multi-account Zerodha Kite Connect positions viewer with a beautiful terminal interface.
+
+```
+  ╦╔═╔═╗╦  ╦
+  ╠╩╗║  ║  ║
+  ╩ ╩╚═╝╩═╝╩
+  Kite Connect CLI
+```
+
+## Architecture
+
+```
+┌─────────────────┐       HTTPS       ┌──────────────────┐      Kite API      ┌─────────────────┐
+│   kcli (CLI)    │ ──────────────── │  FastAPI Server  │ ──────────────────│  Zerodha Kite   │
+│   Your Machine  │                   │  Google Cloud    │                    │  Connect API    │
+└─────────────────┘                   └──────────────────┘                    └─────────────────┘
+        │
+        ▼
+  ~/.kcli/config.yaml
+```
+
+- **CLI (`kcli`)**: Runs on your machine. Beautiful color-coded terminal UI.
+- **Server**: Runs on Google Cloud (Cloud Run). Proxies Kite API calls.
+- **Config**: Multi-account config stored locally at `~/.kcli/config.yaml`.
+
+## Quick Start
+
+### 1. Deploy the Server
+
+```bash
+# Build and deploy to Cloud Run
+cd server
+gcloud run deploy kcli-server \
+  --source . \
+  --region asia-south1 \
+  --allow-unauthenticated \
+  --set-env-vars AUTH_TOKEN=your-secret-token
+```
+
+### 2. Install the CLI
+
+```bash
+# From the project root
+pip install -e .
+```
+
+### 3. Initialize Config
+
+```bash
+# Create the default config file
+kcli config --init
+
+# Edit the config with your accounts
+# Open ~/.kcli/config.yaml and add your Kite API credentials
+```
+
+**Config file format (`~/.kcli/config.yaml`):**
+
+```yaml
+server:
+  url: "https://your-cloud-run-url.run.app"
+  auth_token: "your-secret-token"
+
+accounts:
+  - name: "Trading Account 1"
+    api_key: "your_api_key_1"
+    api_secret: "your_api_secret_1"
+  - name: "Trading Account 2"
+    api_key: "your_api_key_2"
+    api_secret: "your_api_secret_2"
+```
+
+### 4. Login to Kite
+
+```bash
+# Initialize and authenticate all accounts
+kcli init
+```
+
+This will:
+1. Send your account configs to the server
+2. Display login URLs for each account
+3. Prompt you to paste the `request_token` after logging in via browser
+
+> **Note:** Kite access tokens expire daily (~6 AM IST). You need to run `kcli init` once each trading day.
+
+### 5. View Positions
+
+```bash
+# View positions across all accounts
+kcli positions
+```
+
+## Commands
+
+| Command | Description |
+|---|---|
+| `kcli init` | Authenticate all accounts (daily) |
+| `kcli positions` | View positions across all accounts |
+| `kcli status` | Check authentication status |
+| `kcli config --init` | Create default config file |
+| `kcli config --show` | Show current config (secrets masked) |
+| `kcli config --path` | Print config file path |
+
+## Development
+
+### Run Server Locally
+
+```bash
+cd server
+pip install -r requirements.txt
+AUTH_TOKEN=test-token uvicorn main:app --reload --port 8080
+```
+
+### Run CLI
+
+```bash
+pip install -e .
+kcli --help
+```
+
+## Getting Kite API Credentials
+
+1. Go to [Kite Developer Console](https://developers.kite.trade/)
+2. Create a new app
+3. Note your **API Key** and **API Secret**
+4. Set the **Redirect URL** to your server's callback URL
+
+## License
+
+MIT

kitecli-0.1.0b1/README.md

@@ -0,0 +1,133 @@
+# KCLI — Kite Connect CLI
+
+A multi-account Zerodha Kite Connect positions viewer with a beautiful terminal interface.
+
+```
+  ╦╔═╔═╗╦  ╦
+  ╠╩╗║  ║  ║
+  ╩ ╩╚═╝╩═╝╩
+  Kite Connect CLI
+```
+
+## Architecture
+
+```
+┌─────────────────┐       HTTPS       ┌──────────────────┐      Kite API      ┌─────────────────┐
+│   kcli (CLI)    │ ──────────────── │  FastAPI Server  │ ──────────────────│  Zerodha Kite   │
+│   Your Machine  │                   │  Google Cloud    │                    │  Connect API    │
+└─────────────────┘                   └──────────────────┘                    └─────────────────┘
+        │
+        ▼
+  ~/.kcli/config.yaml
+```
+
+- **CLI (`kcli`)**: Runs on your machine. Beautiful color-coded terminal UI.
+- **Server**: Runs on Google Cloud (Cloud Run). Proxies Kite API calls.
+- **Config**: Multi-account config stored locally at `~/.kcli/config.yaml`.
+
+## Quick Start
+
+### 1. Deploy the Server
+
+```bash
+# Build and deploy to Cloud Run
+cd server
+gcloud run deploy kcli-server \
+  --source . \
+  --region asia-south1 \
+  --allow-unauthenticated \
+  --set-env-vars AUTH_TOKEN=your-secret-token
+```
+
+### 2. Install the CLI
+
+```bash
+# From the project root
+pip install -e .
+```
+
+### 3. Initialize Config
+
+```bash
+# Create the default config file
+kcli config --init
+
+# Edit the config with your accounts
+# Open ~/.kcli/config.yaml and add your Kite API credentials
+```
+
+**Config file format (`~/.kcli/config.yaml`):**
+
+```yaml
+server:
+  url: "https://your-cloud-run-url.run.app"
+  auth_token: "your-secret-token"
+
+accounts:
+  - name: "Trading Account 1"
+    api_key: "your_api_key_1"
+    api_secret: "your_api_secret_1"
+  - name: "Trading Account 2"
+    api_key: "your_api_key_2"
+    api_secret: "your_api_secret_2"
+```
+
+### 4. Login to Kite
+
+```bash
+# Initialize and authenticate all accounts
+kcli init
+```
+
+This will:
+1. Send your account configs to the server
+2. Display login URLs for each account
+3. Prompt you to paste the `request_token` after logging in via browser
+
+> **Note:** Kite access tokens expire daily (~6 AM IST). You need to run `kcli init` once each trading day.
+
+### 5. View Positions
+
+```bash
+# View positions across all accounts
+kcli positions
+```
+
+## Commands
+
+| Command | Description |
+|---|---|
+| `kcli init` | Authenticate all accounts (daily) |
+| `kcli positions` | View positions across all accounts |
+| `kcli status` | Check authentication status |
+| `kcli config --init` | Create default config file |
+| `kcli config --show` | Show current config (secrets masked) |
+| `kcli config --path` | Print config file path |
+
+## Development
+
+### Run Server Locally
+
+```bash
+cd server
+pip install -r requirements.txt
+AUTH_TOKEN=test-token uvicorn main:app --reload --port 8080
+```
+
+### Run CLI
+
+```bash
+pip install -e .
+kcli --help
+```
+
+## Getting Kite API Credentials
+
+1. Go to [Kite Developer Console](https://developers.kite.trade/)
+2. Create a new app
+3. Note your **API Key** and **API Secret**
+4. Set the **Redirect URL** to your server's callback URL
+
+## License
+
+MIT

kitecli-0.1.0b1/cli/__init__.py

@@ -0,0 +1 @@
+# KiteCLI - Kite Connect CLI

kitecli-0.1.0b1/cli/api_client.py

@@ -0,0 +1,322 @@
+"""
+Local KiteCLI client.
+
+Wraps KiteAccountManager directly — no HTTP server needed.
+Public API is identical to the old HTTP-based KCLIClient so that
+cli/main.py and cli/live_session.py require zero changes.
+"""
+
+from concurrent.futures import ThreadPoolExecutor
+from cli.kite_manager import KiteAccountManager
+
+
+class KCLIClientError(Exception):
+    """Raised when a Kite API call fails."""
+
+
+# Module-level singleton so session state persists across calls within the process.
+_manager = KiteAccountManager()
+
+
+class KCLIClient:
+    """Local client that delegates directly to KiteAccountManager.
+
+    Args:
+        accounts: List of account dicts from config (name, api_key, api_secret,
+                  user_id, password, totp_secret, proxy).  Accounts are
+                  initialised eagerly on construction so that session tokens are
+                  restored before the first command runs.
+    """
+
+    def __init__(self, accounts: list[dict]) -> None:
+        self._accounts = accounts
+        self._api_keys = [a.get("api_key", "") for a in accounts]
+        # Eagerly init all accounts (restores saved sessions if available)
+        for acct in accounts:
+            _manager.init_account(
+                api_key=acct.get("api_key", ""),
+                api_secret=acct.get("api_secret", ""),
+                name=acct.get("name", ""),
+                proxy=acct.get("proxy"),
+            )
+
+    # ── compatibility helpers ──────────────────────────────────────
+
+    def health_check(self) -> bool:
+        """Always True — no server to ping in local mode."""
+        return True
+
+    # ── public API (mirrors old KCLIClient exactly, but runs in parallel) ──
+
+    def init_accounts(self, accounts: list[dict]) -> dict:
+        """Initialise (or re-initialise) accounts and attempt auto-login in parallel."""
+        def init_one(acct):
+            api_key = acct.get("api_key", "")
+            name = acct.get("name", api_key)
+
+            login_url = _manager.init_account(
+                api_key=api_key,
+                api_secret=acct.get("api_secret", ""),
+                name=name,
+                proxy=acct.get("proxy"),
+            )
+
+            if _manager.is_authenticated(api_key):
+                return {
+                    "name": name,
+                    "api_key": api_key,
+                    "login_url": login_url,
+                    "auto_logged_in": True,
+                    "message": "Session restored from saved token",
+                }
+
+            user_id = acct.get("user_id")
+            password = acct.get("password")
+            totp_secret = acct.get("totp_secret")
+            if user_id and password and totp_secret:
+                success = _manager.auto_login(
+                    api_key=api_key,
+                    user_id=user_id,
+                    password=password,
+                    totp_secret=totp_secret,
+                )
+                if success:
+                    return {
+                        "name": name,
+                        "api_key": api_key,
+                        "login_url": login_url,
+                        "auto_logged_in": True,
+                        "message": "Auto-login successful",
+                    }
+                else:
+                    return {
+                        "name": name,
+                        "api_key": api_key,
+                        "login_url": login_url,
+                        "auto_logged_in": False,
+                        "message": "Auto-login failed. Use manual login URL.",
+                    }
+            else:
+                return {
+                    "name": name,
+                    "api_key": api_key,
+                    "login_url": login_url,
+                    "auto_logged_in": False,
+                    "message": "Credentials incomplete — manual login required.",
+                }
+
+        with ThreadPoolExecutor(max_workers=max(1, len(accounts))) as executor:
+            results = list(executor.map(init_one, accounts))
+
+        return {"accounts": results}
+
+    def complete_callback(self, api_key: str, request_token: str) -> dict:
+        """Complete Kite OAuth login with a request token."""
+        try:
+            success = _manager.complete_login(api_key, request_token.strip())
+            if success:
+                return {"status": "success", "message": "Login successful"}
+            return {"status": "error", "message": "Login failed — check request_token"}
+        except Exception as exc:
+            raise KCLIClientError(str(exc)) from exc
+
+    def get_positions(self, api_keys: list[str]) -> dict:
+        """Fetch open positions for the given accounts in parallel."""
+        keys = api_keys or _manager.get_all_api_keys()
+
+        def fetch_one(api_key):
+            info = _manager.get_account_info(api_key)
+            if not info.get("authenticated"):
+                return {
+                    "name": info.get("name", api_key),
+                    "api_key": api_key,
+                    "positions": [],
+                    "total_pnl": 0.0,
+                    "status": "unauthenticated",
+                }
+            try:
+                positions = _manager.get_positions(api_key)
+                total_pnl = sum(p.get("pnl", 0.0) for p in positions)
+                return {
+                    "name": info.get("name", api_key),
+                    "api_key": api_key,
+                    "positions": positions,
+                    "total_pnl": total_pnl,
+                    "status": "success",
+                }
+            except Exception as exc:
+                return {
+                    "name": info.get("name", api_key),
+                    "api_key": api_key,
+                    "positions": [],
+                    "total_pnl": 0.0,
+                    "status": f"error: {exc}",
+                }
+
+        with ThreadPoolExecutor(max_workers=max(1, len(keys))) as executor:
+            results = list(executor.map(fetch_one, keys))
+
+        return {"accounts": results}
+
+    def get_status(self) -> dict:
+        """Get authentication status for all accounts."""
+        accounts = [
+            _manager.get_account_info(api_key)
+            for api_key in _manager.get_all_api_keys()
+        ]
+        return {"accounts": accounts}
+
+    def place_order(
+        self,
+        api_keys: list[str],
+        tradingsymbol: str,
+        exchange: str,
+        transaction_type: str,
+        quantity: int,
+        order_type: str,
+        price: float | None = None,
+        trigger_price: float | None = None,
+        product: str = "NRML",
+    ) -> dict:
+        """Place an order across specified accounts in parallel."""
+        keys = api_keys or _manager.get_all_api_keys()
+
+        def place_one(api_key):
+            info = _manager.get_account_info(api_key)
+            if not info.get("authenticated"):
+                return {
+                    "name": info.get("name", api_key),
+                    "api_key": api_key,
+                    "status": "error",
+                    "order_id": None,
+                    "message": "Account not authenticated",
+                }
+            try:
+                order_id = _manager.place_order(
+                    api_key=api_key,
+                    tradingsymbol=tradingsymbol,
+                    exchange=exchange,
+                    transaction_type=transaction_type,
+                    quantity=quantity,
+                    order_type=order_type,
+                    price=price,
+                    trigger_price=trigger_price,
+                    product=product,
+                )
+                return {
+                    "name": info.get("name", api_key),
+                    "api_key": api_key,
+                    "status": "success",
+                    "order_id": str(order_id),
+                    "message": f"Order placed: {order_id}",
+                }
+            except Exception as exc:
+                return {
+                    "name": info.get("name", api_key),
+                    "api_key": api_key,
+                    "status": "error",
+                    "order_id": None,
+                    "message": str(exc),
+                }
+
+        with ThreadPoolExecutor(max_workers=max(1, len(keys))) as executor:
+            results = list(executor.map(place_one, keys))
+
+        return {"results": results}
+
+    def exit_positions(
+        self,
+        api_keys: list[str],
+        tradingsymbol: str | None = None,
+    ) -> dict:
+        """Exit positions across specified accounts in parallel."""
+        keys = api_keys or _manager.get_all_api_keys()
+
+        def exit_one(api_key):
+            info = _manager.get_account_info(api_key)
+            if not info.get("authenticated"):
+                return {
+                    "name": info.get("name", api_key),
+                    "api_key": api_key,
+                    "status": "error",
+                    "message": "Account not authenticated",
+                    "orders_placed": [],
+                }
+            try:
+                orders = _manager.exit_positions(api_key, tradingsymbol)
+                return {
+                    "name": info.get("name", api_key),
+                    "api_key": api_key,
+                    "status": "success",
+                    "message": f"Exited {len(orders)} position(s)",
+                    "orders_placed": orders,
+                }
+            except Exception as exc:
+                return {
+                    "name": info.get("name", api_key),
+                    "api_key": api_key,
+                    "status": "error",
+                    "message": str(exc),
+                    "orders_placed": [],
+                }
+
+        with ThreadPoolExecutor(max_workers=max(1, len(keys))) as executor:
+            results = list(executor.map(exit_one, keys))
+
+        return {"results": results}
+
+    def get_option_chain(
+        self,
+        api_key: str,
+        underlying: str,
+        expiry_week: int = 0,
+        expiry_date: str | None = None,
+    ) -> dict:
+        """Fetch option chain for a specific underlying and expiry."""
+        try:
+            return _manager.get_option_chain(
+                api_key=api_key,
+                underlying=underlying,
+                expiry_week=expiry_week,
+                expiry_date=expiry_date,
+            )
+        except Exception as exc:
+            raise KCLIClientError(str(exc)) from exc
+
+    def get_orders(self, api_keys: list[str]) -> dict:
+        """Fetch today's order book for specified accounts in parallel."""
+        keys = api_keys or _manager.get_all_api_keys()
+
+        def fetch_one(api_key):
+            info = _manager.get_account_info(api_key)
+            if not info.get("authenticated"):
+                return {
+                    "name": info.get("name", api_key),
+                    "api_key": api_key,
+                    "orders": [],
+                    "status": "unauthenticated",
+                }
+            try:
+                orders = _manager.get_orders(api_key)
+                return {
+                    "name": info.get("name", api_key),
+                    "api_key": api_key,
+                    "orders": orders,
+                    "status": "success",
+                }
+            except Exception as exc:
+                return {
+                    "name": info.get("name", api_key),
+                    "api_key": api_key,
+                    "orders": [],
+                    "status": f"error: {exc}",
+                }
+
+        with ThreadPoolExecutor(max_workers=max(1, len(keys))) as executor:
+            results = list(executor.map(fetch_one, keys))
+
+        return {"accounts": results}
+
+    def get_market_indices(self) -> dict:
+        """Fetch live Nifty, Sensex, and India VIX."""
+        return _manager.get_market_indices()

kitecli-0.1.0b1/cli/config.py

@@ -0,0 +1,75 @@
+"""
+Configuration management for KiteCLI.
+
+Handles reading, writing, and creating default configuration files
+stored at ~/.kcli/config.yaml.
+"""
+
+from pathlib import Path
+from typing import Optional
+
+import yaml
+
+CONFIG_DIR = Path.home() / ".kcli"
+CONFIG_FILE = CONFIG_DIR / "config.yaml"
+
+DEFAULT_CONFIG = {
+    "accounts": [
+        {
+            "name": "Account 1",
+            "api_key": "your_api_key",
+            "api_secret": "your_api_secret",
+            "user_id": "your_zerodha_user_id",
+            "password": "your_zerodha_password",
+            "totp_secret": "your_totp_secret",
+            "proxy": "http://user:pass@host:port",
+        },
+    ],
+}
+
+
+def load_config() -> Optional[dict]:
+    """Load configuration from ~/.kcli/config.yaml.
+
+    Returns:
+        dict with configuration values, or None if the config file
+        does not exist.
+    """
+    if not CONFIG_FILE.exists():
+        return None
+
+    with open(CONFIG_FILE, "r") as f:
+        config = yaml.safe_load(f)
+
+    # Automatically migrate/remove legacy server config if present
+    if config and "server" in config:
+        del config["server"]
+        save_config(config)
+
+    return config
+
+
+def save_config(config: dict) -> None:
+    """Write configuration to ~/.kcli/config.yaml.
+
+    Creates the config directory if it does not already exist.
+
+    Args:
+        config: Configuration dictionary to persist.
+    """
+    CONFIG_DIR.mkdir(parents=True, exist_ok=True)
+    with open(CONFIG_FILE, "w") as f:
+        yaml.dump(config, f, default_flow_style=False, sort_keys=False)
+
+
+def create_default_config() -> dict:
+    """Create and save a default template configuration.
+
+    The template contains placeholder values that the user should
+    replace with their own credentials.
+
+    Returns:
+        The default configuration dictionary that was saved.
+    """
+    save_config(DEFAULT_CONFIG)
+    return DEFAULT_CONFIG