kkunal 1.0.0__py3-none-any.whl

choice_api/__init__.py

@@ -0,0 +1,22 @@
+from .client import ChoiceClient
+from .orders import OrdersAPI
+from .portfolio import PortfolioAPI
+from .funds import FundsAPI
+from .market import MarketAPI
+from .historical import HistoricalAPI
+from .scrip_master import ScripMaster
+from .websockets_interactive import InteractiveSocketClient
+from .websockets_feed import PriceFeedSocketClient
+
+__version__ = "1.0.0"
+__all__ = [
+    "ChoiceClient",
+    "OrdersAPI",
+    "PortfolioAPI",
+    "FundsAPI",
+    "MarketAPI",
+    "HistoricalAPI",
+    "ScripMaster",
+    "InteractiveSocketClient",
+    "PriceFeedSocketClient"
+]

choice_api/client.py

@@ -0,0 +1,190 @@
+import requests
+import base64
+import os
+import json
+import datetime
+from typing import Dict, Any, Optional
+from Crypto.Cipher import AES
+from Crypto.Util.Padding import pad
+
+from .orders import OrdersAPI
+from .portfolio import PortfolioAPI
+from .funds import FundsAPI
+from .market import MarketAPI
+from .historical import HistoricalAPI
+from .scrip_master import ScripMaster
+
+class ChoiceClient:
+    """
+    Main client for interacting with the Choice API.
+    Handles authentication, session management, and provides access to other API modules.
+    """
+    def __init__(self, vendor_id: str, vendor_key: str, api_key: str, aes_key: str, aes_iv: str, base_url: str = "https://finxomne.choiceindia.com"):
+        self.vendor_id = vendor_id
+        self.vendor_key = vendor_key
+        self.api_key = api_key
+        self.aes_key = aes_key
+        self.aes_iv = aes_iv
+        self.base_url = base_url.rstrip('/')
+        
+        self.session_id: Optional[str] = None
+        self.access_token: Optional[str] = None
+        self.bcast_ip: Optional[str] = None
+        self.bcast_port: Optional[int] = None
+        
+        # Initialize sub-modules
+        self.orders = OrdersAPI(self)
+        self.portfolio = PortfolioAPI(self)
+        self.funds = FundsAPI(self)
+        self.market = MarketAPI(self)
+        self.historical = HistoricalAPI(self)
+        self.scrip_master = ScripMaster()
+
+    def _get_encrypted_mobile(self, mobile_no: str) -> str:
+        """Encrypts the mobile number using AES CBC with the provided keys."""
+        aes_key_bytes = self.aes_key.encode('utf-8')
+        aes_iv_bytes = self.aes_iv.encode('utf-8')
+        cipher = AES.new(aes_key_bytes, AES.MODE_CBC, aes_iv_bytes)
+        padded = pad(mobile_no.encode('utf-8'), AES.block_size)
+        encrypted = cipher.encrypt(padded)
+        return base64.b64encode(encrypted).decode('utf-8')
+
+    def get_headers(self, include_auth: bool = True) -> Dict[str, str]:
+        """Constructs headers required for API requests."""
+        headers = {
+            "VendorId": self.vendor_id,
+            "VendorKey": self.vendor_key,
+            "Bearer": self.api_key,
+            "Content-Type": "application/json"
+        }
+        if include_auth and self.session_id:
+            headers["Authorization"] = f"SessionId {self.session_id}"
+        return headers
+
+    def request(self, method: str, endpoint: str, data: Optional[Dict[str, Any]] = None, require_auth: bool = True) -> Dict[str, Any]:
+        """Base method for making HTTP requests to the API."""
+        url = f"{self.base_url}/{endpoint.lstrip('/')}"
+        headers = self.get_headers(include_auth=require_auth)
+        
+        response = requests.request(method, url, headers=headers, json=data)
+        
+        try:
+            response.raise_for_status()
+            return response.json()
+        except requests.exceptions.HTTPError as e:
+            raise Exception(f"HTTP Request failed: {e}\nResponse: {response.text}")
+        except json.JSONDecodeError:
+            raise Exception(f"Failed to decode JSON response: {response.text}")
+
+    def login(self, mobile_no: str) -> str:
+        """
+        Executes the full TOTP login flow to obtain a SessionId.
+        Flow:
+        1. LoginTOTP
+        2. GetClientLoginTOTP (Retrieve OTP)
+        3. ValidateTOTP (Submit OTP to get SessionId)
+        
+        Returns:
+            The acquired SessionId.
+        """
+        enc_mobile = self._get_encrypted_mobile(mobile_no)
+        
+        # Step 1: Request TOTP
+        resp1 = self.request("POST", "api/OpenAPIV1/LoginTOTP", {"MobileNo": enc_mobile}, require_auth=False)
+        if resp1.get("Status") != "Success":
+            raise Exception(f"LoginTOTP failed: {resp1}")
+            
+        # Step 2: Get OTP generated
+        resp2 = self.request("POST", "api/OpenAPIV1/GetClientLoginTOTP", {"MobileNo": enc_mobile}, require_auth=False)
+        if resp2.get("Status") != "Success":
+            raise Exception(f"GetClientLoginTOTP failed: {resp2}")
+        
+        otp = resp2.get("Response")
+        if not otp:
+            raise Exception(f"OTP not found in response: {resp2}")
+            
+        # Step 3: Validate TOTP
+        resp3 = self.request("POST", "api/OpenAPIV1/ValidateTOTP", {"MobileNo": enc_mobile, "OTP": str(otp)}, require_auth=False)
+        if resp3.get("Status") != "Success":
+            raise Exception(f"ValidateTOTP failed: {resp3}")
+            
+        # Extract Session ID and other details
+        response_data = resp3.get("Response", {})
+        if isinstance(response_data, str):
+            self.session_id = response_data
+        elif isinstance(response_data, dict):
+            self.session_id = response_data.get("SessionId") or response_data.get("session_id")
+            self.access_token = response_data.get("AccessToken")
+            self.bcast_ip = response_data.get("OdinBcastIP")
+            
+            bcast_port_raw = response_data.get("OdinBcastPort")
+            if bcast_port_raw:
+                try:
+                    self.bcast_port = int(bcast_port_raw)
+                except ValueError:
+                    self.bcast_port = None
+            
+            # If AccessToken isn't present, fallback to the Bearer API_KEY since 
+            # some versions of the API allow the same JWT to be reused for the WS.
+            if not self.access_token:
+                self.access_token = self.api_key
+            
+        if not self.session_id:
+            raise Exception("Failed to extract SessionId from ValidateTOTP response")
+            
+        # Automatically fetch the daily scrip master
+        try:
+            self.scrip_master.fetch()
+        except Exception as e:
+            print(f"Warning: Failed to fetch scrip master during login: {e}")
+            
+        return self.session_id
+
+    def save_session(self, filepath: str) -> bool:
+        """Saves the current active session to a file."""
+        if not self.session_id:
+            return False
+        try:
+            with open(filepath, 'w') as f:
+                json.dump({
+                    "date": datetime.date.today().isoformat(),
+                    "session_id": self.session_id,
+                    "access_token": self.access_token,
+                    "bcast_ip": self.bcast_ip,
+                    "bcast_port": self.bcast_port
+                }, f)
+            return True
+        except Exception as e:
+            print(f"Warning: Failed to save session file: {e}")
+            return False
+
+    def load_session(self, filepath: str) -> bool:
+        """Attempts to load a valid session for today from a file."""
+        if not os.path.exists(filepath):
+            return False
+        try:
+            with open(filepath, 'r') as f:
+                data = json.load(f)
+            if data.get("date") == datetime.date.today().isoformat():
+                self.session_id = data.get("session_id")
+                self.access_token = data.get("access_token")
+                self.bcast_ip = data.get("bcast_ip")
+                self.bcast_port = data.get("bcast_port")
+                if not self.access_token:
+                    self.access_token = self.api_key
+                    
+                # Pre-load scrip master
+                try:
+                    self.scrip_master.fetch()
+                except:
+                    pass
+                return True
+            return False
+        except Exception:
+            return False
+        
+    def logoff(self) -> Dict[str, Any]:
+        """Logs out the current session."""
+        response = self.request("GET", "api/OpenAPI/LogOff")
+        self.session_id = None
+        return response

choice_api/funds.py

@@ -0,0 +1,69 @@
+from typing import Dict, Any, Optional
+
+class FundsAPI:
+    def __init__(self, client):
+        self.client = client
+        
+    def get_funds_view(self) -> Dict[str, Any]:
+        """Retrieves funds summary."""
+        return self.client.request("GET", "api/OpenAPI/FundsView")
+
+    def get_funds_view_new(self) -> Dict[str, Any]:
+        """Retrieves the new format funds summary."""
+        return self.client.request("GET", "api/OpenAPI/FundsViewNew")
+
+    def process_payout(self, amount: float, bank_acc_no: str, product_type: int = 0) -> Dict[str, Any]:
+        """Initiates a fund payout request."""
+        payload = {
+            "Amount": amount,
+            "ProductType": product_type,
+            "BankAccNo": bank_acc_no
+        }
+        return self.client.request("POST", "api/OpenAPI/ProcessPayout", payload)
+        
+    def payment_via_netbanking(self, amount: float, bank_acc_no: str, bank_ifsc_code: str, return_url: str,
+                               segment_id: int, product_type: int = 0) -> Dict[str, Any]:
+        """Initiates payment via net banking."""
+        payload = {
+            "Amount": amount,
+            "BankAccNo": bank_acc_no,
+            "BankIFSCCode": bank_ifsc_code,
+            "ReturnUrl": return_url,
+            "ProductType": product_type,
+            "SegmentId": segment_id
+        }
+        return self.client.request("POST", "api/OpenAPI/PaymentViaNB", payload)
+
+    def payment_via_hdfc_upi(self, amount: float, bank_acc_no: str, user_vpa: str, 
+                             segment_id: int, product_type: int = 0) -> Dict[str, Any]:
+        """Initiates payment via HDFC UPI."""
+        payload = {
+            "Amount": amount,
+            "BankAccNo": bank_acc_no,
+            "ProductType": product_type,
+            "SegmentId": segment_id,
+            "UserVPA": user_vpa
+        }
+        return self.client.request("POST", "api/OpenAPI/PaymentViaHDFCUPI", payload)
+
+    def check_vpa(self, user_vpa: str) -> Dict[str, Any]:
+        """Checks if a VPA is valid."""
+        return self.client.request("POST", "api/OpenAPI/CheckVPA", {"UserVPA": user_vpa})
+
+    def payment_via_razorpay(self, amount: float, bank_acc_no: str, bank_ifsc_code: str, upi_id: str,
+                             segment_id: int, payment_type: int = 0, product_type: int = 0) -> Dict[str, Any]:
+        """Initiates payment via RazorPay."""
+        payload = {
+            "Amount": amount,
+            "BankAccNo": bank_acc_no,
+            "BankIFSCCode": bank_ifsc_code,
+            "ProductType": product_type,
+            "PaymentType": payment_type,
+            "UPIId": upi_id,
+            "SegmentId": segment_id
+        }
+        return self.client.request("POST", "api/OpenAPI/PaymentViaRazorPay", payload)
+
+    def payment_ack_response(self, transaction_id: str) -> Dict[str, Any]:
+        """Acknowledges a payment response."""
+        return self.client.request("POST", "api/OpenAPI/PaymentAckResponse", {"TransactionId": transaction_id})

choice_api/historical.py

@@ -0,0 +1,87 @@
+from typing import Dict, Any, Union, TYPE_CHECKING
+from datetime import datetime
+
+if TYPE_CHECKING:
+    import pandas as pd
+
+class HistoricalAPI:
+    def __init__(self, client):
+        self.client = client
+        
+    def _parse_date(self, date_val: Union[str, int]) -> int:
+        if isinstance(date_val, int):
+            return date_val
+        epoch_1980 = datetime(1980, 1, 1)
+        try:
+            if " " in date_val:
+                dt = datetime.strptime(date_val, "%Y-%m-%d %H:%M:%S")
+            else:
+                dt = datetime.strptime(date_val, "%Y-%m-%d")
+            return int((dt - epoch_1980).total_seconds())
+        except Exception:
+            return 0
+        
+    def get_historical_data(self, segment_id: int, token: int, from_date: Union[str, int], to_date: Union[str, int], resolution: str) -> "pd.DataFrame":
+        """
+        Retrieves historical chart data (e.g., OHLCV) as a Pandas DataFrame.
+        
+        Args:
+            segment_id: Exchange Segment ID (e.g., 1 for NSE Cash).
+            token: Instrument token.
+            from_date: Start date (format 'YYYY-MM-DD' or 'YYYY-MM-DD HH:MM:SS' or seconds from 1980).
+            to_date: End date (format 'YYYY-MM-DD' or 'YYYY-MM-DD HH:MM:SS' or seconds from 1980).
+            resolution: Timeframe (e.g., '1', '5', 'D').
+        """
+        import pandas as pd
+        
+        payload = {
+            "SegmentId": segment_id,
+            "Token": token,
+            "FromDate": self._parse_date(from_date),
+            "ToDate": self._parse_date(to_date),
+            "Interval": resolution
+        }
+        
+        resp = self.client.request("POST", "api/OpenGraph/ChartData", payload)
+        
+        if resp.get("Status") == "Success":
+            data = resp.get("Response", {})
+            history = data.get("lstChartHistory", [])
+            divisor = data.get("PriceDivisor", 1)
+            
+            if not history:
+                return pd.DataFrame()
+                
+            parsed_data = []
+            for row in history:
+                parts = row.split(',')
+                # Usually: Time, Open, High, Low, Close, Volume, OI
+                if len(parts) >= 7:
+                    parsed_data.append([
+                        int(parts[0]),
+                        float(parts[1]) / divisor if divisor else float(parts[1]),
+                        float(parts[2]) / divisor if divisor else float(parts[2]),
+                        float(parts[3]) / divisor if divisor else float(parts[3]),
+                        float(parts[4]) / divisor if divisor else float(parts[4]),
+                        int(parts[5]),
+                        int(parts[6])
+                    ])
+                else:
+                    parsed_row = [float(p) / divisor if idx in (1,2,3,4) else float(p) for idx, p in enumerate(parts)]
+                    parsed_data.append(parsed_row)
+            
+            columns = ["Time", "Open", "High", "Low", "Close", "Volume", "OI"]
+            if parsed_data and len(parsed_data[0]) <= len(columns):
+                df = pd.DataFrame(parsed_data, columns=columns[:len(parsed_data[0])])
+            else:
+                df = pd.DataFrame(parsed_data)
+                
+            if "Time" in df.columns:
+                df["Time"] = pd.to_datetime(df["Time"], unit='s', origin=pd.Timestamp('1980-01-01'))
+                
+            return df
+        
+        # If not successful, return empty dataframe or raise? 
+        # Return empty DataFrame to maintain return type consistency, 
+        # as self.client.request raises Exception for HTTP errors.
+        return pd.DataFrame()

choice_api/market.py

@@ -0,0 +1,22 @@
+from typing import Dict, Any
+
+class MarketAPI:
+    def __init__(self, client):
+        self.client = client
+        
+    def get_market_status(self) -> Dict[str, Any]:
+        """Retrieves current market status across segments."""
+        return self.client.request("GET", "api/OpenAPI/MarketStatus")
+
+    def get_user_profile(self) -> Dict[str, Any]:
+        """Retrieves user profile information."""
+        return self.client.request("GET", "api/OpenAPI/UserProfile")
+
+    def get_multiple_touchline(self, multiple_seg_token: str) -> Dict[str, Any]:
+        """
+        Retrieves multiple touchlines.
+        
+        Args:
+            multiple_seg_token: Comma-separated list of segments and tokens.
+        """
+        return self.client.request("POST", "api/OpenAPI/MultipleTouchline", {"MultipleSegToken": multiple_seg_token})

choice_api/orders.py

@@ -0,0 +1,93 @@
+from typing import Dict, Any, Optional
+
+class OrdersAPI:
+    def __init__(self, client):
+        self.client = client
+        
+    def place_order(self, segment_id: int, token: int, order_type: str, bs: int, qty: int,
+                    price: float, trigger_price: float, validity: int, product_type: str, 
+                    disclosed_qty: int = 0, is_edis_req: bool = False) -> Dict[str, Any]:
+        """Places a new order."""
+        payload = {
+            "SegmentId": segment_id,
+            "Token": token,
+            "OrderType": order_type,
+            "BS": bs,
+            "Qty": qty,
+            "DisclosedQty": disclosed_qty,
+            "Price": price,
+            "TriggerPrice": trigger_price,
+            "Validity": validity,
+            "ProductType": product_type,
+            "IsEdisReq": is_edis_req,
+            "Remarks": "API",
+            "ModeTyp": "WEBAPI",
+            "Mode": 1,
+            "DeviceId": "MAC",
+            "ClientOrderNo": 123456
+        }
+        return self.client.request("POST", "api/OpenAPI/V2/NewOrder", payload)
+
+    def modify_order(self, client_order_no: int, exchange_order_no: str, gateway_order_no: str,
+                     segment_id: int, token: int, order_type: str, bs: int, qty: int, price: float,
+                     trigger_price: float, validity: int, product_type: str, disclosed_qty: int = 0) -> Dict[str, Any]:
+        """Modifies an existing order."""
+        payload = {
+            "ClientOrderNo": client_order_no,
+            "ExchangeOrderNo": exchange_order_no,
+            "GatewayOrderNo": gateway_order_no,
+            "SegmentId": segment_id,
+            "Token": token,
+            "OrderType": order_type,
+            "BS": bs,
+            "Qty": qty,
+            "DisclosedQty": disclosed_qty,
+            "Price": price,
+            "TriggerPrice": trigger_price,
+            "Validity": validity,
+            "ProductType": product_type
+        }
+        return self.client.request("POST", "api/OpenAPI/ModifyOrder", payload)
+
+    def cancel_order(self, client_order_no: int, exchange_order_no: str, gateway_order_no: str,
+                     segment_id: int, token: int, order_type: str, bs: int, qty: int, price: float,
+                     trigger_price: float, validity: int, product_type: str, exchange_order_time: str = "",
+                     disclosed_qty: int = 0) -> Dict[str, Any]:
+        """Cancels an order."""
+        payload = {
+            "ExchangeOrderTime": exchange_order_time,
+            "ClientOrderNo": client_order_no,
+            "ExchangeOrderNo": exchange_order_no,
+            "GatewayOrderNo": gateway_order_no,
+            "SegmentId": segment_id,
+            "Token": token,
+            "OrderType": order_type,
+            "BS": bs,
+            "Qty": qty,
+            "DisclosedQty": disclosed_qty,
+            "Price": price,
+            "TriggerPrice": trigger_price,
+            "Validity": validity,
+            "ProductType": product_type
+        }
+        return self.client.request("POST", "api/OpenAPI/CancelOrder", payload)
+
+    def get_order_book(self) -> Dict[str, Any]:
+        """Retrieves the full order book."""
+        return self.client.request("GET", "api/OpenAPI/OrderBook")
+
+    def get_order_book_v2(self) -> Dict[str, Any]:
+        """Retrieves order book version 2."""
+        return self.client.request("GET", "api/OpenAPI/OrderBookV2")
+
+    def get_order_by_no(self, order_no: int) -> Dict[str, Any]:
+        """Retrieves a specific order by its order number."""
+        return self.client.request("GET", f"api/OpenAPI/OrderBookByOrderNo/{order_no}")
+
+    def get_trade_book(self) -> Dict[str, Any]:
+        """Retrieves the trade book."""
+        return self.client.request("GET", "api/OpenAPI/TradeBook")
+
+    def get_order_messages(self, req_id: str) -> Dict[str, Any]:
+        """Retrieves order messages."""
+        return self.client.request("POST", "api/OpenAPI/OrderMessages", {"ReqId": req_id})

choice_api/portfolio.py

@@ -0,0 +1,43 @@
+from typing import Dict, Any, List
+
+class PortfolioAPI:
+    def __init__(self, client):
+        self.client = client
+        
+    def get_holdings(self) -> Dict[str, Any]:
+        """Retrieves user's holdings."""
+        return self.client.request("GET", "api/OpenAPI/Holdings")
+
+    def get_net_position(self) -> Dict[str, Any]:
+        """Retrieves the net position of the user."""
+        return self.client.request("GET", "api/OpenAPI/NetPosition")
+
+    def position_conversion(self, segment_id: int, token: int, client_order_no: int, buy_sell: int,
+                            quantity: int, product_type: str, source_product_type: str, is_edis_req: bool = True) -> Dict[str, Any]:
+        """Converts an open position from one product type to another."""
+        payload = {
+            "SegmentId": segment_id,
+            "Token": token,
+            "ClientOrderNo": client_order_no,
+            "BuySell": buy_sell,
+            "Quantity": quantity,
+            "ProductType": product_type,
+            "SourceProductType": source_product_type,
+            "IsEDISReq": is_edis_req
+        }
+        return self.client.request("POST", "api/OpenAPI/PositionConversion", payload)
+
+    def verify_dis(self, boid: str, ctr_boid: str, ex_id: int, channel: int, edis_stocks: List[Dict[str, Any]]) -> Dict[str, Any]:
+        """Verifies eDIS."""
+        payload = {
+            "BOID": boid,
+            "CtrBOID": ctr_boid,
+            "ExId": ex_id,
+            "channel": channel,
+            "eDISStocks": edis_stocks
+        }
+        return self.client.request("POST", "api/OpenAPI/VerifyDIS", payload)
+
+    def get_dis_status(self) -> Dict[str, Any]:
+        """Retrieves the DIS status."""
+        return self.client.request("POST", "api/OpenAPI/GetDISStatus", {})

choice_api/scrip_master.py

@@ -0,0 +1,105 @@
+import csv
+import urllib.request
+import logging
+from datetime import datetime, timedelta
+
+logger = logging.getLogger(__name__)
+
+class ScripMaster:
+    """
+    Manages downloading and parsing the daily Scrip Master from Choice API.
+    Provides fast lookups for Tokens, Lot Sizes, and Symbols.
+    """
+    def __init__(self):
+        self.symbol_to_token = {}
+        self.token_to_details = {}
+        self.is_loaded = False
+
+    def fetch(self):
+        """
+        Fetches the Scrip Master CSV for the current date.
+        If today's file is unavailable (e.g., weekends/holidays early morning), 
+        it falls back to the previous day.
+        """
+        logger.info("Fetching daily scrip master...")
+        
+        # Try today, then yesterday, then the day before
+        for days_back in range(3):
+            target_date = datetime.now() - timedelta(days=days_back)
+            date_str = target_date.strftime("%d%b%Y")
+            url = f"https://scripmaster.choiceindia.com/scripmaster/SCRIP_MASTER_{date_str}.csv"
+            
+            try:
+                req = urllib.request.Request(url, headers={'User-Agent': 'Mozilla/5.0'})
+                with urllib.request.urlopen(req, timeout=10) as response:
+                    # Decode the response and parse as CSV
+                    lines = (line.decode('utf-8', errors='ignore') for line in response)
+                    reader = csv.DictReader(lines)
+                    
+                    count = 0
+                    for row in reader:
+                        token = row.get('Token', '').strip()
+                        if not token:
+                            continue
+                            
+                        symbol = row.get('Symbol', '').strip()
+                        sec_desc = row.get('SecDesc', '').strip()
+                        
+                        # Store complete details
+                        self.token_to_details[token] = row
+                        
+                        # Map symbol/sec_desc to token for reverse lookup
+                        if sec_desc:
+                            self.symbol_to_token[sec_desc] = token
+                        if symbol and symbol not in self.symbol_to_token:
+                            self.symbol_to_token[symbol] = token
+                            
+                        count += 1
+                        
+                self.is_loaded = True
+                logger.info(f"Successfully loaded {count} symbols from {date_str} master.")
+                return True
+                
+            except urllib.error.HTTPError as e:
+                if e.code == 404:
+                    logger.debug(f"Scrip master not found for {date_str}, trying previous day.")
+                    continue
+                else:
+                    logger.error(f"HTTP Error fetching scrip master: {e}")
+                    break
+            except Exception as e:
+                logger.error(f"Failed to fetch scrip master: {e}")
+                break
+                
+        logger.warning("Could not download Scrip Master.")
+        return False
+
+    def get_token(self, symbol_or_desc: str, exchange: str = None) -> str:
+        """
+        Returns the Token for a given Symbol or SecDesc.
+        If exchange is provided (e.g., 'NSE' or 'BSE'), it will ensure the exact match for that exchange.
+        """
+        if exchange:
+            exchange_upper = exchange.upper().strip()
+            for token, details in self.token_to_details.items():
+                d_symbol = details.get('Symbol', '').strip()
+                d_sec_desc = details.get('SecDesc', '').strip()
+                d_exch = details.get('Exchange', '').strip().upper()
+                if (d_symbol == symbol_or_desc or d_sec_desc == symbol_or_desc) and d_exch == exchange_upper:
+                    return token
+            return None
+            
+        return self.symbol_to_token.get(symbol_or_desc)
+
+    def get_details(self, token: str) -> dict:
+        """Returns all CSV row details for a given Token."""
+        return self.token_to_details.get(str(token), {})
+
+    def get_lot_size(self, token: str) -> int:
+        """Helper to quickly get the lot size for a token."""
+        details = self.get_details(token)
+        lot_size_str = details.get("MarketLot", "1")
+        try:
+            return int(lot_size_str)
+        except ValueError:
+            return 1

choice_api/websockets_feed.py

@@ -0,0 +1,106 @@
+import asyncio
+import zlib
+import logging
+from typing import Callable
+
+logger = logging.getLogger(__name__)
+
+class PriceFeedSocketClient:
+    """
+    Live Price Feed Socket using FIX3.0 delimited ASCII formats and Zlib compression.
+    """
+    def __init__(self, host: str, port: int, user_id: str):
+        self.host = host
+        self.port = port
+        self.user_id = user_id
+        self.reader = None
+        self.writer = None
+        self._connected = False
+        self._callbacks = []
+
+    def on_message(self, callback: Callable):
+        """Registers a callback for parsed feed messages."""
+        self._callbacks.append(callback)
+
+    async def connect(self):
+        """Connects to the Web Feed Handler via TCP Socket."""
+        try:
+            self.reader, self.writer = await asyncio.open_connection(self.host, self.port)
+            self._connected = True
+            logger.info(f"Connected to Price Feed Socket at {self.host}:{self.port}")
+            
+            # Send Logon Request
+            await self.send_login()
+            await self._listen()
+        except Exception as e:
+            logger.error(f"Failed to connect to Price Feed Socket: {e}")
+
+    async def disconnect(self):
+        """Disconnects the socket."""
+        self._connected = False
+        if self.writer:
+            self.writer.close()
+            await self.writer.wait_closed()
+            logger.info("Disconnected from Price Feed Socket.")
+
+    async def send_login(self):
+        """Sends the Logon Request (101)."""
+        # Format: 63=FIX3.0|64=101|65=66|66=2022-05-04 133022|400=11|67=USERID|68=|
+        login_msg = f"63=FIX3.0|64=101|65=66|66=2023-03-06 113929|67={self.user_id}|68=|400=11"
+        self._send_raw(login_msg)
+
+    def subscribe_touchline(self, session_id: str, segment_id: int, token: int):
+        """Subscribes to Touchline (Market Data)."""
+        # Message code 206
+        msg = f"63=FIX3.0|64=206|65=107|66=2023-02-11 19:02:31|1=1$7={token}|230=1|4={session_id}|"
+        self._send_raw(msg)
+
+    def subscribe_best_five(self, session_id: str, segment_id: int, token: int):
+        """Subscribes to Best Five (Depth Data)."""
+        # Message code 127
+        msg = f"63=FIX3.0|64=127|65=84|66=2023-03-06 19:02:31|1=1|7={token}|230=1|4={session_id}"
+        self._send_raw(msg)
+
+    def _send_raw(self, msg: str):
+        """Sends a raw uncompressed message (first byte = '2', next 5 bytes = length)."""
+        length_str = str(len(msg)).zfill(5)
+        packet = f"2{length_str}{msg}".encode('utf-8')
+        if self.writer:
+            self.writer.write(packet)
+            logger.debug(f"Sent: {msg}")
+
+    async def _listen(self):
+        """Listens and decompresses incoming messages."""
+        try:
+            while self._connected and self.reader:
+                # Read 6 byte header: 1 byte type, 5 bytes length
+                header = await self.reader.readexactly(6)
+                msg_type = chr(header[0])
+                msg_len = int(header[1:6].decode('ascii'))
+                
+                payload = await self.reader.readexactly(msg_len)
+                
+                if msg_type == '5': # Compressed
+                    try:
+                        decompressed = zlib.decompress(payload)
+                        self._process_message(decompressed.decode('ascii', errors='ignore'))
+                    except Exception as e:
+                        logger.error(f"Zlib decompression failed: {e}")
+                elif msg_type == '2': # Uncompressed
+                    self._process_message(payload.decode('ascii', errors='ignore'))
+                else:
+                    logger.warning(f"Unknown message format indicator: {msg_type}")
+        except asyncio.IncompleteReadError:
+            logger.info("Connection closed by server.")
+            self._connected = False
+        except Exception as e:
+            logger.error(f"Feed listen error: {e}")
+
+    def _process_message(self, raw_str: str):
+        """Parses the FIX3.0 pipe delimited string."""
+        # Simple split by pipe
+        for cb in self._callbacks:
+            try:
+                cb(raw_str)
+            except Exception as e:
+                logger.error(f"Feed callback error: {e}")

choice_api/websockets_interactive.py

@@ -0,0 +1,94 @@
+import asyncio
+import json
+import logging
+import websockets
+from typing import Callable, Optional
+
+logger = logging.getLogger(__name__)
+
+class InteractiveSocketClient:
+    """
+    FINX Interactive Socket for receiving order status, trade confirmations, and market events.
+    """
+    def __init__(self, token: str, host: str = "wss://finxsocket.choiceindia.com/ws/"):
+        self.url = f"{host}?token={token}"
+        self.ws: Optional[websockets.WebSocketClientProtocol] = None
+        self._connected = False
+        self._callbacks = {
+            "MKT_STAT": [],
+            "ORD_NRML": [],
+            "TRD_MSG": [],
+            "error": []
+        }
+        self._keepalive_task = None
+
+    def on(self, event_type: str, callback: Callable):
+        """Registers a callback for a specific MessageType (MKT_STAT, ORD_NRML, TRD_MSG)."""
+        if event_type in self._callbacks:
+            self._callbacks[event_type].append(callback)
+
+    async def connect(self):
+        """Connects to the interactive socket."""
+        try:
+            self.ws = await websockets.connect(self.url)
+            self._connected = True
+            logger.info("Connected to FINX Interactive Socket.")
+            self._keepalive_task = asyncio.create_task(self._keepalive())
+            await self._listen()
+        except Exception as e:
+            logger.error(f"Failed to connect to Interactive Socket: {e}")
+            self._trigger_callbacks("error", e)
+
+    async def disconnect(self):
+        """Disconnects the socket."""
+        self._connected = False
+        if self._keepalive_task:
+            self._keepalive_task.cancel()
+        if self.ws:
+            await self.ws.close()
+            logger.info("Disconnected from Interactive Socket.")
+
+    async def _keepalive(self):
+        """Sends '2' every 25 seconds to keep the connection alive."""
+        try:
+            while self._connected and self.ws:
+                await asyncio.sleep(25)
+                await self.ws.send("2")
+                logger.debug("Sent heartbeat (2)")
+        except asyncio.CancelledError:
+            pass
+        except Exception as e:
+            logger.error(f"Keepalive error: {e}")
+
+    async def _listen(self):
+        """Listens for incoming messages."""
+        try:
+            while self._connected and self.ws:
+                message = await self.ws.recv()
+                if message == "3":
+                    logger.debug("Received heartbeat ack (3)")
+                    continue
+                
+                try:
+                    data = json.loads(message)
+                    msg_type = data.get("MessageType")
+                    if msg_type:
+                        self._trigger_callbacks(msg_type, data)
+                    else:
+                        logger.warning(f"Unknown message format: {message}")
+                except json.JSONDecodeError:
+                    logger.warning(f"Non-JSON message received: {message}")
+        except websockets.exceptions.ConnectionClosed:
+            logger.info("Connection closed by server.")
+            self._connected = False
+        except Exception as e:
+            logger.error(f"Listen error: {e}")
+            self._trigger_callbacks("error", e)
+
+    def _trigger_callbacks(self, event_type: str, data):
+        """Triggers all callbacks registered for an event type."""
+        for cb in self._callbacks.get(event_type, []):
+            try:
+                cb(data)
+            except Exception as e:
+                logger.error(f"Error in callback for {event_type}: {e}")

kkunal-1.0.0.dist-info/METADATA

@@ -0,0 +1,410 @@
+Metadata-Version: 2.4
+Name: kkunal
+Version: 1.0.0
+Summary: Kkunal - Python library for Choice FINX Trading API
+Author: Kkunal
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: requests>=2.28.0
+Requires-Dist: pycryptodome>=3.17.0
+Requires-Dist: websockets>=11.0.3
+Requires-Dist: pandas>=1.3.0
+Dynamic: author
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: license-file
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+# Kkunal
+
+A Python library for the Choice FINX Trading API. Supports REST API, Interactive WebSockets (order/trade updates), and Live Price Feed WebSockets (FIX3.0 compressed data).
+
+## Installation
+
+```bash
+pip install kkunal
+```
+
+All dependencies (`requests`, `pycryptodome`, `websockets`, `pandas`) are installed automatically.
+
+---
+
+## Quick Start
+
+```python
+from choice_api import ChoiceClient
+
+client = ChoiceClient(
+    vendor_id="YOUR_VENDOR_ID",
+    vendor_key="YOUR_VENDOR_KEY",
+    api_key="YOUR_JWT_BEARER_TOKEN",
+    aes_key="YOUR_AES_KEY",
+    aes_iv="YOUR_AES_IV"
+)
+
+# Login (TOTP flow is handled automatically)
+session_id = client.login(mobile_no="1234567890")
+print(f"Session ID: {session_id}")
+```
+
+### Session Persistence
+
+You can save and reload sessions to avoid logging in repeatedly during the same trading day:
+
+```python
+session_file = "my_session.json"
+
+if client.load_session(session_file):
+    print("Restored today's session.")
+else:
+    client.login(mobile_no="1234567890")
+    client.save_session(session_file)
+```
+
+> **Note:** Sessions expire daily. `load_session` will return `False` if the saved session is from a previous day.
+
+---
+
+## Scrip Master
+
+The Scrip Master CSV is automatically downloaded when you log in. It maps instrument symbols to their tokens, lot sizes, and other metadata.
+
+### `get_token(symbol, exchange=None)`
+
+Returns the token for a given symbol.
+
+- For **NSE** instruments, no `exchange` parameter is needed (returns NSE by default).
+- For **BSE** instruments, pass `exchange="BSE"` explicitly.
+
+```python
+# NSE (default)
+reliance_token = client.scrip_master.get_token("RELIANCE")
+
+# BSE (must specify exchange)
+reliance_bse_token = client.scrip_master.get_token("RELIANCE", exchange="BSE")
+```
+
+### `get_details(token)`
+
+Returns all CSV row details for a given token as a dictionary.
+
+```python
+details = client.scrip_master.get_details("2885")
+print(details)
+# {'Exchange': 'NSE', 'Segment': '1', 'Token': '2885', 'Symbol': 'RELIANCE', ...}
+```
+
+### `get_lot_size(token)`
+
+Returns the market lot size for a token.
+
+```python
+lot = client.scrip_master.get_lot_size("2885")
+print(lot)  # 1 for equity, 250 for NIFTY futures, etc.
+```
+
+---
+
+## Orders
+
+> **Important:** Prices must be in **paisa** (multiply INR by 100). For F&O orders, `qty` must be in **total shares** (multiples of the lot size), not the number of lots.
+
+### `client.orders.place_order(...)`
+
+| Parameter | Type | Description |
+|---|---|---|
+| `segment_id` | `int` | `1` = NSE Cash, `2` = NSE F&O, `3` = BSE Cash |
+| `token` | `int` | Instrument token from Scrip Master |
+| `order_type` | `str` | `"RL_MKT"` = Market, `"RL_LIMIT"` = Limit |
+| `bs` | `int` | `1` = Buy, `2` = Sell |
+| `qty` | `int` | Total quantity in shares |
+| `price` | `float` | Price in paisa (e.g., 1300 INR → `130000`) |
+| `trigger_price` | `float` | Trigger price in paisa (0 for non-SL orders) |
+| `validity` | `int` | `1` = Day |
+| `product_type` | `str` | `"M"` = Intraday (Margin), `"D"` = Delivery/CarryForward |
+| `disclosed_qty` | `int` | Optional. Disclosed quantity (default `0`) |
+
+```python
+response = client.orders.place_order(
+    segment_id=1,
+    token=2885,
+    order_type="RL_MKT",
+    bs=1,
+    qty=1,
+    price=0,
+    trigger_price=0,
+    validity=1,
+    product_type="D"
+)
+```
+
+### `client.orders.modify_order(...)`
+
+Modifies an existing order. Requires `client_order_no`, `exchange_order_no`, and `gateway_order_no` from the order book.
+
+```python
+response = client.orders.modify_order(
+    client_order_no=123456,
+    exchange_order_no="1234567890",
+    gateway_order_no="1234567890",
+    segment_id=1,
+    token=2885,
+    order_type="RL_LIMIT",
+    bs=1,
+    qty=1,
+    price=130000,
+    trigger_price=0,
+    validity=1,
+    product_type="D"
+)
+```
+
+### `client.orders.cancel_order(...)`
+
+Cancels an existing order. Same parameters as `modify_order` plus optional `exchange_order_time`.
+
+### `client.orders.get_order_book()`
+
+Returns all orders placed during the current session.
+
+```python
+order_book = client.orders.get_order_book()
+```
+
+### `client.orders.get_order_book_v2()`
+
+Returns the order book (version 2 format).
+
+### `client.orders.get_order_by_no(order_no)`
+
+Returns details for a specific order number.
+
+```python
+order = client.orders.get_order_by_no(123456)
+```
+
+### `client.orders.get_trade_book()`
+
+Returns all executed trades.
+
+```python
+trades = client.orders.get_trade_book()
+```
+
+### `client.orders.get_order_messages(req_id)`
+
+Returns order-related messages for a given request ID.
+
+---
+
+## Portfolio
+
+### `client.portfolio.get_holdings()`
+
+Returns current holdings.
+
+```python
+holdings = client.portfolio.get_holdings()
+```
+
+### `client.portfolio.get_net_position()`
+
+Returns net positions.
+
+```python
+positions = client.portfolio.get_net_position()
+```
+
+### `client.portfolio.position_conversion(...)`
+
+Converts an open position from one product type to another (e.g., Intraday to Delivery).
+
+| Parameter | Type | Description |
+|---|---|---|
+| `segment_id` | `int` | Exchange segment |
+| `token` | `int` | Instrument token |
+| `client_order_no` | `int` | Client order number |
+| `buy_sell` | `int` | `1` = Buy, `2` = Sell |
+| `quantity` | `int` | Quantity to convert |
+| `product_type` | `str` | Target product type |
+| `source_product_type` | `str` | Current product type |
+
+### `client.portfolio.verify_dis(...)`
+
+Verifies eDIS (Electronic Delivery Instruction Slip) for delivery sell orders.
+
+### `client.portfolio.get_dis_status()`
+
+Returns the current DIS verification status.
+
+---
+
+## Funds
+
+### `client.funds.get_funds_view()`
+
+Returns funds summary.
+
+```python
+funds = client.funds.get_funds_view()
+```
+
+### `client.funds.get_funds_view_new()`
+
+Returns funds summary in the new format.
+
+### `client.funds.process_payout(amount, bank_acc_no, product_type=0)`
+
+Initiates a fund withdrawal.
+
+### `client.funds.payment_via_netbanking(amount, bank_acc_no, bank_ifsc_code, return_url, segment_id, product_type=0)`
+
+Initiates a net banking payment.
+
+### `client.funds.payment_via_hdfc_upi(amount, bank_acc_no, user_vpa, segment_id, product_type=0)`
+
+Initiates a HDFC UPI payment.
+
+### `client.funds.check_vpa(user_vpa)`
+
+Validates a UPI VPA address.
+
+### `client.funds.payment_via_razorpay(amount, bank_acc_no, bank_ifsc_code, upi_id, segment_id, payment_type=0, product_type=0)`
+
+Initiates a RazorPay payment.
+
+### `client.funds.payment_ack_response(transaction_id)`
+
+Acknowledges a payment transaction.
+
+---
+
+## Market
+
+### `client.market.get_market_status()`
+
+Returns current market status across all segments.
+
+```python
+status = client.market.get_market_status()
+```
+
+### `client.market.get_user_profile()`
+
+Returns the authenticated user's profile.
+
+```python
+profile = client.market.get_user_profile()
+```
+
+### `client.market.get_multiple_touchline(multiple_seg_token)`
+
+Returns touchline data for multiple instruments.
+
+```python
+# Format: "SegmentId1,Token1|SegmentId2,Token2"
+touchline = client.market.get_multiple_touchline("1,2885|1,11536")
+```
+
+---
+
+## Historical Data
+
+### `client.historical.get_historical_data(segment_id, token, from_date, to_date, resolution)`
+
+Returns historical OHLCV data as a **Pandas DataFrame**.
+
+| Parameter | Type | Description |
+|---|---|---|
+| `segment_id` | `int` | Exchange segment |
+| `token` | `int` | Instrument token |
+| `from_date` | `str` or `int` | Start date (`"YYYY-MM-DD"` or seconds from 1980) |
+| `to_date` | `str` or `int` | End date (`"YYYY-MM-DD"` or seconds from 1980) |
+| `resolution` | `str` | `"1"` = 1 min, `"5"` = 5 min, `"D"` = Daily |
+
+```python
+df = client.historical.get_historical_data(
+    segment_id=1,
+    token=2885,
+    from_date="2024-01-01",
+    to_date="2024-12-31",
+    resolution="D"
+)
+print(df.head())
+#                   Time     Open     High      Low    Close   Volume  OI
+# 0  2024-01-01 00:00:00  2501.00  2520.50  2490.00  2515.30  1234567   0
+```
+
+The returned DataFrame has columns: `Time`, `Open`, `High`, `Low`, `Close`, `Volume`, `OI`. Prices are automatically adjusted using the `PriceDivisor` from the API response.
+
+---
+
+## Interactive WebSockets
+
+Receives live order updates, trade confirmations, and market status events.
+
+```python
+import asyncio
+from choice_api import InteractiveSocketClient
+
+async def main():
+    ws = InteractiveSocketClient(token=client.session_id)
+
+    ws.on("ORD_NRML", lambda data: print(f"Order Update: {data}"))
+    ws.on("TRD_MSG", lambda data: print(f"Trade: {data}"))
+    ws.on("MKT_STAT", lambda data: print(f"Market Status: {data}"))
+
+    await ws.connect()
+
+asyncio.run(main())
+```
+
+**Event types:** `ORD_NRML` (order updates), `TRD_MSG` (trade confirmations), `MKT_STAT` (market open/close).
+
+---
+
+## Price Feed WebSockets (FIX3.0)
+
+Receives live Level 1 (Touchline) and Level 2 (Best Five / Depth) market data via TCP socket with Zlib compression.
+
+```python
+import asyncio
+from choice_api import PriceFeedSocketClient
+
+async def main():
+    feed = PriceFeedSocketClient(
+        host=client.bcast_ip,
+        port=client.bcast_port,
+        user_id="YOUR_USER_ID"
+    )
+
+    feed.on_message(lambda raw: print(f"Feed: {raw}"))
+
+    # Start connection (sends login automatically)
+    asyncio.create_task(feed.connect())
+
+    # Wait for connection, then subscribe
+    await asyncio.sleep(2)
+    feed.subscribe_touchline(client.session_id, segment_id=1, token=2885)
+    feed.subscribe_best_five(client.session_id, segment_id=1, token=2885)
+
+    # Keep running
+    await asyncio.sleep(3600)
+
+asyncio.run(main())
+```
+
+---
+
+## Logoff
+
+```python
+client.logoff()
+```

kkunal-1.0.0.dist-info/RECORD

@@ -0,0 +1,15 @@
+choice_api/__init__.py,sha256=fY65cwH-JaEdWKAhq3-Ml8-_JHZwFhbld5wmoBU5s3o,570
+choice_api/client.py,sha256=Ak9LYlT7A60DL8DGYQ1FqBBF84OcTxfkrV4f6CcZTQs,7664
+choice_api/funds.py,sha256=i0wAEdgOVbeJ_fKsj48TnJvBPnZd_nvqtCX98S47zYU,2991
+choice_api/historical.py,sha256=3nv9XpRA6vr3wvnVoYnZiYFRDYW_G_S_jaZ0KG5oNBQ,3641
+choice_api/market.py,sha256=EQPy7H6M4NgiMCQwiMTO-T-jn38qUNmCWsvuOWGW7tY,834
+choice_api/orders.py,sha256=Fpm9Y10J5c4dpEQCH7k998q3qzT8OcI5e9CqUkX3kUY,3958
+choice_api/portfolio.py,sha256=5O1iQCzHnkw-2x6mJlfINsVZcn_9jUpHXJmGoEWwzfM,1775
+choice_api/scrip_master.py,sha256=suvihBC94Ju0iE0txHftickOXHySPhEo0kb8pMh14v4,4398
+choice_api/websockets_feed.py,sha256=SQAGFV3CMoQS_1kmE4Uf_IP4hhDq7Ah6DCSrN1c814I,4236
+choice_api/websockets_interactive.py,sha256=bGWNnFcuECmFIAoK9F7yxF5YMBqAokI8_gg6gYch588,3553
+kkunal-1.0.0.dist-info/licenses/LICENSE,sha256=Uov9DNV_BCILceTqoxV67xKBx7xFisUYLV_jas2RWoQ,1062
+kkunal-1.0.0.dist-info/METADATA,sha256=t6cBhWOJcKHbtFINGkDKfd0vsBIvRiDRbfGhjIKLzTk,10212
+kkunal-1.0.0.dist-info/WHEEL,sha256=K260EYznzXsJYBQGqmI8VTxEdiZYNvDZwW9cBh9-_MA,91
+kkunal-1.0.0.dist-info/top_level.txt,sha256=VsLK_s-yRDOGB9DrN_5TkpyT-ejeAXp_kKygPh9_z18,11
+kkunal-1.0.0.dist-info/RECORD,,

kkunal-1.0.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (83.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

kkunal-1.0.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Kkunal
+
+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.

kkunal-1.0.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+choice_api