pyarrow-client 1.0.0__py3-none-any.whl

pyarrow/__version__.py

@@ -0,0 +1,10 @@
+__title__ = 'pyarrow-client'  # Match the PyPI package name
+__version__ = '1.0.0'
+__description__ = 'Official Python Client Library for Arrow Trading API'
+__url__ = 'https://arrow.trade'
+__download_url__ = 'https://pypi.org/project/py-arrow/'
+__license__ = 'MIT'
+__author__ = 'Abhishek Jain'
+__author_email__ = 'abhishek.jain@irage.in'
+__maintainer__ = 'Arrow Trading Team'
+__maintainer_email__ = 'support@arrow.trade'

pyarrow/arrow_utils.py

@@ -0,0 +1,230 @@
+expiry_dates = {
+    "NIFTY": {
+        "2018": [
+            "25-Jan-2018",
+            "22-Feb-2018",
+            "28-Mar-2018",
+            "29-Mar-2018",
+            "26-Apr-2018",
+            "31-May-2018",
+            "28-Jun-2018",
+            "26-Jul-2018",
+            "30-Aug-2018",
+            "27-Sep-2018",
+            "25-Oct-2018",
+            "29-Nov-2018",
+            "27-Dec-2018"
+        ],
+        "2019": [
+            "31-Jan-2019",
+            "14-Feb-2019",
+            "21-Feb-2019",
+            "28-Feb-2019",
+            "07-Mar-2019",
+            "14-Mar-2019",
+            "20-Mar-2019",
+            "28-Mar-2019",
+            "04-Apr-2019",
+            "11-Apr-2019",
+            "18-Apr-2019",
+            "25-Apr-2019",
+            "02-May-2019",
+            "09-May-2019",
+            "16-May-2019",
+            "23-May-2019",
+            "30-May-2019",
+            "06-Jun-2019",
+            "13-Jun-2019",
+            "20-Jun-2019",
+            "27-Jun-2019",
+            "04-Jul-2019",
+            "11-Jul-2019",
+            "18-Jul-2019",
+            "25-Jul-2019",
+            "01-Aug-2019",
+            "08-Aug-2019",
+            "14-Aug-2019",
+            "22-Aug-2019",
+            "29-Aug-2019",
+            "05-Sep-2019",
+            "12-Sep-2019",
+            "19-Sep-2019",
+            "26-Sep-2019",
+            "03-Oct-2019",
+            "10-Oct-2019",
+            "17-Oct-2019",
+            "24-Oct-2019",
+            "31-Oct-2019",
+            "07-Nov-2019",
+            "14-Nov-2019",
+            "21-Nov-2019",
+            "28-Nov-2019",
+            "05-Dec-2019",
+            "12-Dec-2019",
+            "19-Dec-2019",
+            "26-Dec-2019"
+        ],
+        "2020": [
+            "02-Jan-2020",
+            "09-Jan-2020",
+            "16-Jan-2020",
+            "23-Jan-2020",
+            "30-Jan-2020",
+            "06-Feb-2020",
+            "13-Feb-2020",
+            "20-Feb-2020",
+            "27-Feb-2020",
+            "05-Mar-2020",
+            "12-Mar-2020",
+            "19-Mar-2020",
+            "26-Mar-2020",
+            "01-Apr-2020",
+            "09-Apr-2020",
+            "16-Apr-2020",
+            "23-Apr-2020",
+            "30-Apr-2020",
+            "07-May-2020",
+            "14-May-2020",
+            "21-May-2020",
+            "28-May-2020",
+            "04-Jun-2020",
+            "11-Jun-2020",
+            "18-Jun-2020",
+            "25-Jun-2020",
+            "02-Jul-2020",
+            "09-Jul-2020",
+            "16-Jul-2020",
+            "23-Jul-2020",
+            "30-Jul-2020",
+            "06-Aug-2020",
+            "13-Aug-2020",
+            "20-Aug-2020",
+            "27-Aug-2020",
+            "03-Sep-2020",
+            "10-Sep-2020",
+            "17-Sep-2020",
+            "24-Sep-2020",
+            "01-Oct-2020",
+            "08-Oct-2020",
+            "15-Oct-2020",
+            "22-Oct-2020",
+            "29-Oct-2020",
+            "05-Nov-2020",
+            "12-Nov-2020",
+            "19-Nov-2020",
+            "26-Nov-2020",
+            "03-Dec-2020",
+            "10-Dec-2020",
+            "17-Dec-2020",
+            "24-Dec-2020",
+            "31-Dec-2020"
+        ],
+        "2021": [
+            "07-Jan-2021",
+            "14-Jan-2021",
+            "21-Jan-2021",
+            "28-Jan-2021",
+            "04-Feb-2021",
+            "11-Feb-2021",
+            "18-Feb-2021",
+            "25-Feb-2021",
+            "04-Mar-2021",
+            "10-Mar-2021",
+            "18-Mar-2021",
+            "25-Mar-2021",
+            "01-Apr-2021",
+            "08-Apr-2021",
+            "15-Apr-2021",
+            "22-Apr-2021",
+            "29-Apr-2021",
+            "06-May-2021",
+            "12-May-2021",
+            "20-May-2021",
+            "27-May-2021",
+            "03-Jun-2021",
+            "10-Jun-2021",
+            "17-Jun-2021",
+            "24-Jun-2021",
+            "01-Jul-2021",
+            "08-Jul-2021",
+            "15-Jul-2021",
+            "22-Jul-2021",
+            "29-Jul-2021",
+            "05-Aug-2021",
+            "12-Aug-2021",
+            "18-Aug-2021",
+            "26-Aug-2021",
+            "02-Sep-2021",
+            "09-Sep-2021",
+            "16-Sep-2021",
+            "23-Sep-2021",
+            "30-Sep-2021",
+            "07-Oct-2021",
+            "14-Oct-2021",
+            "21-Oct-2021",
+            "28-Oct-2021",
+            "03-Nov-2021",
+            "11-Nov-2021",
+            "18-Nov-2021",
+            "25-Nov-2021",
+            "02-Dec-2021",
+            "09-Dec-2021",
+            "16-Dec-2021",
+            "23-Dec-2021",
+            "30-Dec-2021"
+        ],
+        "2022": ["06-Jan-2022",
+                 "13-Jan-2022",
+                 "20-Jan-2022",
+                 "27-Jan-2022",
+                 "03-Feb-2022",
+                 "10-Feb-2022",
+                 "17-Feb-2022",
+                 "24-Feb-2022",
+                 "03-Mar-2022",
+                 "10-Mar-2022",
+                 "17-Mar-2022",
+                 "24-Mar-2022",
+                 "31-Mar-2022",
+                 "07-Apr-2022",
+                 "13-Apr-2022",
+                 "21-Apr-2022",
+                 "28-Apr-2022",
+                 "05-May-2022",
+                 "12-May-2022",
+                 "19-May-2022",
+                 "26-May-2022",
+                 "02-Jun-2022",
+                 "09-Jun-2022",
+                 "16-Jun-2022",
+                 "23-Jun-2022",
+                 "30-Jun-2022",
+                 "07-Jul-2022",
+                 "14-Jul-2022",
+                 "21-Jul-2022",
+                 "28-Jul-2022",
+                 "04-Aug-2022",
+                 "11-Aug-2022",
+                 "18-Aug-2022",
+                 "25-Aug-2022",
+                 "01-Sep-2022",
+                 "08-Sep-2022",
+                 "15-Sep-2022",
+                 "22-Sep-2022",
+                 "29-Sep-2022",
+                 "06-Oct-2022",
+                 "13-Oct-2022",
+                 "20-Oct-2022",
+                 "27-Oct-2022",
+                 "03-Nov-2022",
+                 "10-Nov-2022",
+                 "17-Nov-2022",
+                 "24-Nov-2022",
+                 "01-Dec-2022",
+                 "08-Dec-2022",
+                 "15-Dec-2022",
+                 "22-Dec-2022",
+                 "29-Dec-2022"],
+        
+    }
+}

pyarrow/connect.py

@@ -0,0 +1,399 @@
+from datetime import datetime
+import hashlib
+import json
+import logging
+from typing import Any, Dict, List, Optional, Union
+from urllib.parse import urlparse, parse_qs
+import pyarrow.exceptions as ex
+import pyotp
+from pyarrow.arrow_utils import expiry_dates
+
+from pyarrow.__version__ import __title__, __version__
+from pyarrow.constants import Exchange, OrderType, ProductType, Retention, TransactionType, Variety
+
+import dateutil.parser
+import requests
+import urllib3
+
+import pyarrow.constants as constants
+
+log = logging.getLogger(__name__)
+
+
+class ArrowClient(object):
+    DEFAULT_TIMEOUT = 10
+    DEFAULT_ROOT_URL = "https://edge.arrow.trade"
+    DEFAULT_LOGIN_URL = "https://api.arrow.trade/auth/app/login"
+    VALIDATE_2FA_URL = "https://api.arrow.trade/auth/validate-2fa"
+
+    def __init__(
+            self, app_id: str,
+            timeout: Optional[int] = None,
+            debug: bool = False,
+            root_url: Optional[str] = None,
+            pool_config: Optional[Dict[str, Any]] = None) -> None:
+        self.app_id = app_id
+        self.req_session = requests.Session()
+        self.timeout = timeout or self.DEFAULT_TIMEOUT
+        self.debug = debug
+        self.root_url = root_url or self.DEFAULT_ROOT_URL
+        self.disable_ssl = False
+        self.proxies: Dict[str, str] = {}
+
+        self._token: Optional[str] = None
+        self._routes = constants.Routes(root_url=self.root_url)
+
+    def place_order(self,
+            exchange: Exchange,
+            symbol: str,
+            quantity: int,
+            disclosed_quantity: int,
+            product: ProductType,
+            order_type: OrderType,
+            variety: Variety,
+            transaction_type: TransactionType,
+            price: float,
+            validity: Retention,
+            tags: Optional[str] = None,
+            amo: bool = False,
+            trigger_price: Optional[float] = None) -> str:
+        params = dict(
+            exchange=str(exchange),
+            symbol=symbol,
+            # token=token,
+            quantity="{qty}".format(qty=quantity),
+            disclosedQty="{disclosed_qty}".format(disclosed_qty=disclosed_quantity),
+            product=str(product),
+            order=str(order_type),
+            transactionType=str(transaction_type),
+            price="{price}".format(price=price),
+            validity=str(validity),
+            tags=tags or "",
+            amo=amo,
+            triggerPrice="{trigger_price}".format(trigger_price=trigger_price or "")
+        )  # type: Dict[str, Any]
+        response = self._post(
+            self._routes.PLACE_ORDER,
+            url_args={"variety": str(variety)},
+            params=params
+        )
+        return response["orderNo"]
+
+    def set_token(self, token: str) -> None:
+        self._token = token
+
+    def get_token(self) -> str:
+        return self._token or ""
+
+    def invalidate_session(self) -> None:
+        self._token = None
+
+    # TODO
+    def get_instruments(self) -> Any:
+        # return self._get(self._routes.ALL_INSTRUMENTS)
+        pass
+
+    # Order Routes
+    def get_order(self, order_id: str) -> List[Dict[str, Any]]:
+        data = self._get(self._routes.GET_ORDER_BY_ID, url_args={"order_id": order_id})
+        return self._format_order_response(data)
+
+    def get_orders(self) -> List[Dict[str, Any]]:
+        """Get all user orders."""
+        data = self._get(self._routes.GET_USER_ORDERS)
+        return self._format_orders_response(data)
+
+    def get_trades(self) -> List[Dict[str, Any]]:
+        """Get all user trades."""
+        data = self._get(self._routes.GET_USER_TRADES)
+        return self._format_trades_response(data)
+
+    def modify_order(
+            self,
+            order_id: str,
+            exchange: Exchange,
+            quantity: int,
+            symbol: str,
+            price: float,
+            disclosed_qty: int,
+            product: ProductType,
+            transaction_type: TransactionType,
+            order_type: OrderType,
+            validity: Retention,
+            amo: bool = False,
+            trigger_price: Optional[float] = None,
+            tags: Optional[str] = None,
+            book_loss_price: Optional[float] = None,
+            book_profit_price: Optional[float] = None
+    ) -> str:
+        """Modify an existing order."""
+        params = {
+            "exchange": str(exchange),
+            "quantity": str(quantity),
+            "disclosedQty": str(disclosed_qty),
+            "product": str(product),
+            "symbol": symbol,
+            "transactionType": str(transaction_type),
+            "order": str(order_type),
+            "price": str(price),
+            "validity": str(validity),
+            "triggerPrice": str(trigger_price or "0"),
+            "bookLossPrice": str(book_loss_price or ""),
+            "bookProfitPrice": str(book_profit_price or ""),
+            "tags": tags or "",
+            "amo": amo
+        }
+
+        response = self._patch(
+            self._routes.UPDATE_ORDER_BY_ID,
+            url_args={"order_id": order_id},
+            params=params
+        )
+        return response["message"]
+
+    def cancel_order(self, order_id: str) -> str:
+        """Cancel an existing order."""
+        response = self._delete(
+            self._routes.DELETE_ORDER,
+            url_args={"order_id": order_id}
+        )
+        return response["message"]
+
+    # User Details Routes
+    def get_user_details(self) -> Dict[str, Any]:
+        return self._get(self._routes.USER_DETAILS)
+
+    # User Holdings
+    def get_holdings(self) -> Dict[str, Any]:
+        return self._get(self._routes.GET_USER_HOLDINGS)
+
+    @staticmethod
+    def get_expiry_dates(symbol: str, year: str):
+        return expiry_dates[symbol][year]
+
+    # Margin Routes
+    def get_order_margin(self, params: Dict[str, Any]) -> Dict[str, Any]:
+        return self._post(self._routes.ORDER_MARGIN, params=params)
+
+    def get_basket_margin(self, orders: List[Dict[str, Any]]) -> Dict[str, Any]:
+        return self._post(self._routes.BASKET_MARGIN, params=orders)
+
+    def _authenticate(self, checksum: str, request_token: str) -> Dict[str, str]:
+        params = {
+            "appID": self.app_id,
+            "token": request_token,
+            "checksum": checksum,
+        }
+        response = self._post("https://api.arrow.trade/auth/app/authenticate-token", params=params)
+        if "token" in response:
+            self._token = response["token"]
+            if self.debug:
+                log.debug(f"Token: {self._token}")
+
+        return response
+
+    def login_url(self) -> str:
+        return f"{self._routes.get_home_url()}?appID={self.app_id}"
+
+    def login(self, request_token: str, api_secret: str) -> Dict[str, str]:
+        checksum = self._generate_checksum(request_token, api_secret)
+        response = self._authenticate(checksum, request_token)
+        return response
+
+    def auto_login(self, user_id: str, password: str, api_secret: str, totp_secret: str) -> Dict[str, str]:
+        login_url = self.DEFAULT_LOGIN_URL
+        login_payload = {
+            "userID": user_id,
+            "password": password,
+            "captchaValue": "",
+            "captchaID": None,
+            "appID": self.app_id,
+            "isAppLogin": True
+        }
+
+        # Generate the request ID
+        try:
+            login_resp = self._post(login_url, params=login_payload)
+            request_id = login_resp["requestId"]
+        except Exception as e:
+            log.error("Failed to generate Request id: {}".format(e))
+            raise
+
+        # Generate the totp
+        try:
+            passcode = pyotp.TOTP(totp_secret).now()
+        except Exception as e:
+            log.error("Failed to Generate TOTP: {}".format(e))
+            raise
+
+        # Validate 2FA
+        totp_payload = {
+            "code": passcode,  # Fixed: use passcode instead of request_id
+            "requestId": request_id,
+            "userID": user_id,
+        }
+
+        try:
+            totp_resp = self._post(self.VALIDATE_2FA_URL, params=totp_payload)
+            redirect_url = totp_resp["redirectUrl"]
+        except Exception as e:
+            log.error("Failed to Generate 2FA URL: {}".format(e))
+            raise
+
+        try:
+            parsed_url = urlparse(redirect_url)
+            request_token = parse_qs(parsed_url.query)["request-token"][0]
+        except Exception as e:
+            log.error("Failed to generate request token: {}".format(e))
+            raise
+
+        try:
+            response = self.login(request_token=request_token, api_secret=api_secret)
+            self.set_token(response["token"])
+            return response
+        except Exception as e:
+            log.error("Failed to complete login: {}".format(e))
+            raise
+
+    def _generate_checksum(self, request_token: str, api_secret: str) -> str:
+        input_str = f"{self.app_id}:{api_secret}:{request_token}"
+        return hashlib.sha256(input_str.encode("utf-8")).hexdigest()
+
+    # HTTP Route Methods
+    def _get(self, route: str, url_args: Optional[Dict[str, str]] = None, params: Any = None) -> Any:
+        return self._request("GET", route, url_args, params)
+
+    def _post(self, route: str, url_args: Optional[Dict[str, str]] = None, params: Any = None,
+              query_params: Any = None) -> Any:
+        return self._request("POST", route, url_args, params, query_params)
+
+    def _patch(self, route: str, url_args: Optional[Dict[str, str]] = None, params: Any = None,
+               query_params: Any = None) -> Any:
+        return self._request("PATCH", route, url_args, params, query_params)
+
+    def _delete(self, route: str, url_args: Optional[Dict[str, str]] = None, params: Any = None) -> Any:
+        return self._request("DELETE", route, url_args, params)
+
+    def _request(self, method: str, route: str,
+                 url_args: Optional[Dict[str, str]] = None,
+                 params: Any = None, query_params: Any = None) -> Any:
+        # Build URL
+        url = route.format(**url_args) if url_args else route
+
+        # Headers
+        headers = {
+            "User-Agent": f"pyarrow/{__version__}",
+            "appID": self.app_id,
+            "Content-Type": "application/json"  # Add explicit content type
+        }
+
+        # Only add token header if we actually have a token (not empty string)
+        if self._token:
+            headers["token"] = self._token
+
+        if self.debug:
+            log.debug(f"Request: {method} {url} params={json.dumps(params)} headers={json.dumps(headers)}")
+
+        # Handle parameters correctly
+        json_data = None
+        query_params_final = query_params
+
+        if method in ["POST", "PUT", "PATCH"]:
+            json_data = params
+        elif method in ["GET", "DELETE"] and params:
+            query_params_final = params
+
+        try:
+            r = self.req_session.request(
+                method=method,
+                url=url,
+                json=json_data,
+                params=query_params_final,
+                headers=headers,
+                verify=not self.disable_ssl,
+                allow_redirects=True,
+                timeout=self.timeout,
+                proxies=self.proxies
+            )
+        except Exception as e:
+            raise e
+
+        if self.debug:
+            log.debug(f"Response: {method} {url}\n{r.content[:1000]!r}")
+
+        content_type = r.headers.get("content-type", "")
+
+        # JSON response
+        if "json" in content_type:
+            try:
+                data = r.json()
+            except ValueError:
+                raise ex.DataException(f"Invalid JSON response: {r.content!r}")
+
+            if isinstance(data, dict):
+                if data.get(constants.STATUS) == constants.ERROR or data.get(constants.ERROR_CODE):
+                    if r.status_code == 403:
+                        # TODO: handle session expiry
+                        pass
+                    exp = getattr(ex, str(data.get(constants.ERROR_CODE)), ex.GeneralException)
+                    raise exp(data.get(constants.ERROR_MESSAGE, "Unknown Error"), code=r.status_code)
+                return data.get("data", data)
+            return data
+
+        # Binary response
+        if "octet-stream" in content_type:
+            return r.content
+
+        # Unknown response type
+        raise ex.DataException(f"Unknown Content-Type ({content_type}) Response: {r.content[:1000]!r}")
+
+    # Data Parsing Methods
+    def _format_order_response(self, data: Union[Dict[str, Any], List[Dict[str, Any]]]) -> List[Dict[str, Any]]:
+        """Format order response data."""
+        order_list = [data] if isinstance(data, dict) else data
+        return self._format_datetime_fields(order_list, ["timeStamp", "exchangeUpdateTime", "requestTime"])
+
+    def _format_orders_response(self, data: List[Dict[str, Any]]) -> List[Dict[str, Any]]:
+        """Format orders response data."""
+        return self._format_datetime_fields(data, ["timeStamp", "exchangeUpdateTime"])
+
+    def _format_trades_response(self, data: List[Dict[str, Any]]) -> List[Dict[str, Any]]:
+        """Format trades response data."""
+        return self._format_datetime_fields(data, ["fillTime", "timeStamp", "exchangeUpdateTime", "requestTime"])
+
+    @staticmethod
+    def _format_datetime_fields(data: List[Dict[str, Any]], datetime_fields: List[str]) -> List[Dict[str, Any]]:
+        """Convert datetime strings and epoch times in response data."""
+        for item in data:
+            # Convert datetime strings
+            for field in datetime_fields:
+                if item.get(field) and len(str(item[field])) == 19:
+                    item[field] = dateutil.parser.parse(item[field])
+
+            # Convert epoch time to int
+            if item.get("orderTime"):
+                dt = datetime.strptime(item["orderTime"], "%Y-%m-%dT%H:%M:%S")
+                item["orderTime"] = int(dt.timestamp())
+
+        return data
+
+    def get_holidays(self) -> Dict[str, Any]:
+        return self._get(self._routes.HOLIDAYS_LIST)
+
+    def get_index_list(self) -> List[Dict[str, Any]]:
+        return self._get(self._routes.INDEX_LIST)
+
+    def get_option_chain_symbols(self):
+        return self._get(self._routes.OPTION_CHAIN_SYMBOLS)
+
+    def get_option_chain(self, params: Dict[str, str]) -> List[Dict[str, Any]]:
+        pass
+
+
+    # Properties
+    @property
+    def token(self) -> str:
+        return self._token or ""
+
+
+Arrow = ArrowClient