quantplay 2.0.151__tar.gz → 2.0.161__tar.gz

{quantplay-2.0.151 → quantplay-2.0.161}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: quantplay
-Version: 2.0.151
+Version: 2.0.161
 Summary: This python package will be stored in AWS CodeArtifact
 Home-page: 
 Author: 

{quantplay-2.0.151 → quantplay-2.0.161}/quantplay/broker/icici_direct.py

@@ -146,12 +146,12 @@ class ICICI(Broker):
 
         return self.quantplay_symbol_map[symbol]
 
-    def orders(self, tag: str | None = None, add_ltp: bool = True) -> pl.DataFrame:
+    def orders_by_exchange(self, exchange: ExchangeType):
         to_date = datetime.now().isoformat()[:19] + ".000Z"
         from_date = (datetime.now() - timedelta(hours=10)).isoformat()[:19] + ".000Z"
 
         orders: Dict[str, Any] = self.wrapper.get_order_list(  # type:ignore
-            exchange_code="NFO",
+            exchange_code=exchange,
             from_date=from_date,
             to_date=to_date,
         )
@@ -230,20 +230,21 @@ class ICICI(Broker):
 
         return orders_df
 
+    def orders(self, tag: str | None = None, add_ltp: bool = True) -> pl.DataFrame:
+        nfo_orders = self.orders_by_exchange("NFO")
+        bfo_orders = self.orders_by_exchange("BFO")
+
+        return pl.concat([nfo_orders, bfo_orders])
+
     def positions(self, drop_cnc: bool = True) -> pl.DataFrame:
-        to_date = datetime.now().isoformat()[:19] + ".000Z"
-        from_date = (datetime.now() - timedelta(hours=10)).isoformat()[:19] + ".000Z"
-        positions: Dict[str, Any] = self.wrapper.get_portfolio_holdings(  # type:ignore
-            exchange_code="NFO",
-            from_date=from_date,
-            to_date=to_date,
-            stock_code="",
-            portfolio_type="",
-        )
+        positions: Dict[str, Any] = self.wrapper.get_portfolio_positions()  # type:ignore
+
         if "Success" in positions and positions["Success"] is None:
             return pl.DataFrame(schema=self.positions_schema)
         positions_df = pl.DataFrame(positions["Success"])
-
+        if "realized_profit" not in positions_df:
+            positions_df = positions_df.with_columns(pl.lit(0.0).alias("realized_profit"))
+        positions_df = positions_df.filter(pl.col("exchange_code").is_in(["NFO", "BFO"]))
         positions_df = positions_df.rename(
             {
                 "exchange_code": "exchange",
@@ -252,6 +253,9 @@ class ICICI(Broker):
                 "product_type": "product",
             }
         )
+        positions_df = positions_df.with_columns(
+            pl.col("quantity").cast(pl.Int32).alias("quantity")
+        )
         positions_df = positions_df.with_columns(
             pl.col("strike").cast(pl.Float32).alias("strike"),
             pl.col("expiry").str.strptime(pl.Date, format="%d-%b-%Y").alias("expiry"),
@@ -260,11 +264,11 @@ class ICICI(Broker):
             .when(pl.col("right") == "Put")
             .then(pl.lit("PE"))
             .alias("instrument_type"),
-            (
-                pl.col("unrealized_profit").cast(pl.Float32)
-                + pl.col("realized_profit").cast(pl.Float32)
-            ).alias("pnl"),
-            pl.col("quantity").cast(pl.Int32).alias("quantity"),
+            pl.when(pl.col("action") == "Sell")
+            .then(abs(pl.col("quantity").cast(pl.Float32)) * -1)
+            .otherwise(abs(pl.col("quantity").cast(pl.Float32)))
+            .alias("quantity"),
+            pl.lit(0).alias("pnl"),
             pl.col("average_price").cast(pl.Float32).alias("average_price"),
         )
 
@@ -341,9 +345,14 @@ class ICICI(Broker):
         if tag is None:
             tag = ""
         icici_tradingsymbol = self.get_symbol(tradingsymbol)
-        symbol_data: Dict[str, Any] = self.symbol_data[  # type:ignore
-            f"{exchange}:{icici_tradingsymbol}"
-        ]
+        try:
+            symbol_data: Dict[str, Any] = self.symbol_data[  # type:ignore
+                f"{exchange}:{icici_tradingsymbol}"
+            ]
+        except KeyError:
+            raise QuantplayOrderPlacementException(
+                f"Failed to find tradingsymbol {tradingsymbol}"
+            )
         icici_product = "cash"
         if exchange in ["NFO", "BFO"]:
             icici_product = "futures"
@@ -365,7 +374,7 @@ class ICICI(Broker):
         else:
             response: Dict[str, Any] = self.wrapper.place_order(  # type:ignore
                 stock_code=symbol_data["symbol_code"],
-                exchange_code="NFO",
+                exchange_code=exchange,
                 product=icici_product,
                 action=transaction_type.lower(),
                 order_type=order_type.lower(),
@@ -380,6 +389,8 @@ class ICICI(Broker):
             )
         if "Success" in response and "order_id" in response["Success"]:
             return response["Success"]["order_id"]
+        elif "Error" in response:
+            raise QuantplayOrderPlacementException(response["Error"])
         else:
             raise QuantplayOrderPlacementException(
                 f"ICICI: order placement failed {response}"

{quantplay-2.0.151 → quantplay-2.0.161}/quantplay/broker/kotak.py

@@ -6,6 +6,7 @@ from urllib.parse import urlencode
 
 import polars as pl
 import requests
+import urllib
 
 from quantplay.broker.generics.broker import Broker
 from quantplay.model.broker import (
@@ -20,6 +21,15 @@ from quantplay.model.generics import (
     TransactionType,
 )
 from quantplay.model.order_event import OrderUpdateEvent
+from quantplay.exception.exceptions import (
+    InvalidArgumentException,
+    BrokerException,
+    QuantplayOrderPlacementException,
+)
+from quantplay.utils.constant import Constants
+from quantplay.utils.pickle_utils import InstrumentData
+from quantplay.wrapper.aws.s3 import S3Utils
+import uuid
 
 PROD_BASE_URL = "https://gw-napi.kotaksecurities.com/"
 SESSION_PROD_BASE_URL = "https://napi.kotaksecurities.com/"
@@ -59,6 +69,27 @@ class Kotak(Broker):
         elif consumer_key and consumer_secret and mobilenumber and password and mpin:
             self.login(consumer_key, consumer_secret, mobilenumber, password, mpin)
 
+        if load_instrument:
+            self.load_instrument()
+
+    def load_instrument(self, file_name: str | None = None) -> None:
+        try:
+            self.symbol_data = InstrumentData.get_instance().load_data(  # type: ignore
+                "kotak_instruments"
+            )
+            Constants.logger.info("[LOADING_INSTRUMENTS] loading data from cache")
+        except Exception:
+            inst_data_df = S3Utils.get_parquet(
+                "quantplay-market-data/symbol_data/kotak_instruments.parquet"
+            )
+            inst_data_df = inst_data_df.with_columns(
+                pl.col("tradingsymbol").alias("broker_symbol")
+            )
+            self.instrument_data = inst_data_df
+            self.initialize_symbol_data_v2(save_as="kotak_instruments")
+
+        self.initialize_broker_symbol_map()
+
     def login(
         self,
         consumer_key: str,
@@ -83,7 +114,7 @@ class Kotak(Broker):
         )
 
         if not session_init.ok:
-            raise Exception("")
+            raise InvalidArgumentException(json.loads(session_init.content))
 
         json_resp = json.loads(session_init.text)
         self.configuration["bearer_token"] = json_resp.get("access_token")
@@ -146,6 +177,11 @@ class Kotak(Broker):
         Return the Token in a String Format
         """
 
+    def order_history(self, order_id: str):
+        body = {"nOrdNo": order_id}
+        order_history = self.request("order_history", body=body)["data"]  # type:ignore
+        return pl.DataFrame(order_history)
+
     # **
     # ** GET Api's
     # **
@@ -187,6 +223,7 @@ class Kotak(Broker):
             pl.col("order_timestamp")
             .str.strptime(pl.Datetime(time_unit="ms"), format="%d-%b-%Y %H:%M:%S")
             .alias("order_timestamp"),
+            pl.col("status").str.to_uppercase().alias("status"),
         )
         orders_df = orders_df.with_columns(
             pl.col("order_timestamp").alias("update_timestamp"),
@@ -228,15 +265,79 @@ class Kotak(Broker):
         return orders_df
 
     def positions(self, drop_cnc: bool = True) -> pl.DataFrame:
-        positions_resp = self.request("order_book")
+        positions_resp = self.request("positions")
 
         if positions_resp["stat"] == "Not_Ok" and positions_resp["errMsg"] == "No Data":
             return pl.DataFrame(schema=self.positions_schema)
+        positions_df = pl.DataFrame(positions_resp["data"])
+
+        positions_df = positions_df.rename(
+            {
+                "trdSym": "tradingsymbol",
+                "buyAmt": "buy_value",
+                "sellAmt": "sell_value",
+                "prod": "product",
+                "tok": "token",
+                "exSeg": "exchange",
+                "optTp": "option_type",
+            }
+        )
+        positions_df = positions_df.with_columns(
+            (
+                pl.col("flBuyQty").fill_null(0).cast(pl.Int64)
+                + pl.col("cfBuyQty").fill_null(0).cast(pl.Int64)
+            ).alias("buy_quantity"),
+            (
+                pl.col("flSellQty").fill_null(0).cast(pl.Int64)
+                + pl.col("cfSellQty").fill_null(0).cast(pl.Int64)
+            ).alias("sell_quantity"),
+            pl.lit(None).alias("ltp"),
+            pl.lit(None).alias("pnl"),
+            pl.when(pl.col("exchange") == "nse_cm")
+            .then(pl.lit("NSE"))
+            .when(pl.col("exchange") == "bse_cm")
+            .then(pl.lit("BSE"))
+            .when(pl.col("exchange") == "nse_fo")
+            .then(pl.lit("NFO"))
+            .when(pl.col("exchange") == "bse_fo")
+            .then(pl.lit("BFO"))
+            .when(pl.col("exchange") == "cde_fo")
+            .then(pl.lit("CDS"))
+            .when(pl.col("exchange") == "bcs-fo")
+            .then(pl.lit("BCD"))
+            .when(pl.col("exchange") == "mcx")
+            .then(pl.lit("MCX"))
+            .otherwise(pl.col("exchange"))
+            .alias("exchange"),
+            pl.when(pl.col("option_type") == "XX")
+            .then(pl.lit(None))
+            .otherwise(pl.col("option_type"))
+            .alias("option_type"),
+        )
+        positions_df = positions_df.with_columns(
+            (pl.col("buy_quantity") - pl.col("sell_quantity")).alias("quantity")
+        )
+        positions_df = positions_df.with_columns(
+            (
+                (
+                    pl.col("buy_value").cast(pl.Float32)
+                    - pl.col("sell_value").cast(pl.Float32)
+                )
+                / pl.col("quantity")
+            ).alias("average_price")
+        )
+        positions_df = positions_df[list(self.positions_schema.keys())].cast(
+            self.positions_schema
+        )
+        return positions_df
+
+    def trades(self) -> pl.DataFrame:
+        self.request("trade_report")
 
         return pl.DataFrame(schema=self.positions_schema)
 
     def holdings(self) -> pl.DataFrame:
-        holdings_resp = self.request("order_book")
+        holdings_resp = self.request("holdings")
 
         if holdings_resp["stat"] == "Not_Ok" and holdings_resp["errMsg"] == "No Data":
             return pl.DataFrame(schema=self.holidings_schema)
@@ -289,18 +390,25 @@ class Kotak(Broker):
             "qt": str(quantity),
             "rt": "DAY",
             "tp": str(trigger_price or "0"),
-            "ts": tradingsymbol,
+            "ts": self.get_symbol(tradingsymbol, exchange),
             "tt": self.get_transaction_type(transaction_type),
-            "ig": tag,
+            "ig": str(uuid.uuid4()),
         }
 
-        place_order_resp = self.request("place_order", body=place_order_body)
+        place_order_resp = self.request(  # type:ignore
+            "place_order", body=place_order_body
+        )  # type:ignore
         print(place_order_resp)
 
-        return ""
+        if place_order_resp["stat"] == "Not_Ok":
+            raise QuantplayOrderPlacementException(place_order_resp["errMsg"])
+
+        return place_order_resp["nOrdNo"]
 
     def cancel_order(self, order_id: str, variety: str | None = None) -> None:
-        return
+        body = {"on": order_id, "am": "No"}
+
+        self.request("cancel_order", body=body)
 
     def modify_order(self, order: ModifyOrderRequest) -> str:
         return ""
@@ -339,6 +447,34 @@ class Kotak(Broker):
 
         return exchange_segment_map.get(exchange, exchange)
 
+    def get_quantplay_exchange(self, exchange: str) -> str:
+        exchange_segment_map: dict[str, str] = {
+            "nse_cm": "NSE",
+            "bse_cm": "BSE",
+            "nse_fo": "NFO",
+            "bse_fo": "BFO",
+            "cde_fo": "CDS",
+            "mcx": "MCX",
+        }
+
+        return exchange_segment_map.get(exchange, exchange)
+
+    def get_lot_size(self, exchange: str, tradingsymbol: str):
+        tradingsymbol = self.get_quantplay_symbol(tradingsymbol)
+        exchange = self.get_quantplay_exchange(exchange)
+
+        try:
+            return int(
+                self.symbol_data["{}:{}".format(exchange, tradingsymbol)]["lot_size"]
+            )
+        except Exception as e:
+            Constants.logger.error(
+                "[GET_LOT_SIZE] unable to get lot size for {} {}".format(
+                    exchange, tradingsymbol
+                )
+            )
+            raise e
+
     def get_product(self, product: ProductType) -> str:
         product_map: dict[ProductType, str] = {
             "NRML": "NRML",
@@ -348,6 +484,21 @@ class Kotak(Broker):
 
         return product_map.get(product, product)
 
+    def get_symbol(self, symbol: str, exchange: ExchangeType | None = None):
+        if exchange == "NSE":
+            if symbol in ["NIFTY", "BANKNIFTY"]:
+                return symbol
+            if "-EQ" not in symbol:
+                return f"{symbol}-EQ"
+            else:
+                return symbol
+        if exchange == "BSE":
+            return symbol
+
+        if symbol not in self.quantplay_symbol_map:
+            return symbol
+        return self.quantplay_symbol_map[symbol]
+
     # **
     # ** Kotak Utils
     # **
@@ -375,7 +526,7 @@ class Kotak(Broker):
             "place_order": ("Orders/2.0/quick/order/rule/ms/place", "POST", False),
             "cancel_order": ("Orders/2.0/quick/order/cancel", "POST", False),
             "modify_order": ("Orders/2.0/quick/order/vr/modify", "POST", False),
-            "order_history": ("Orders/2.0/quick/order/history", "GET", True),
+            "order_history": ("Orders/2.0/quick/order/history", "POST", False),
             "order_book": ("Orders/2.0/quick/user/orders", "GET", True),
             "trade_report": ("Orders/2.0/quick/user/trades", "GET", True),
             "positions": ("Orders/2.0/quick/user/positions", "GET", True),
@@ -406,23 +557,26 @@ class Kotak(Broker):
 
         query_params = {"sId": self.configuration["serverId"]}
         if item == "place_order":
-            query_params["sId"] = "server4"
-            request_headers["neo-fin-key"] = "neotradeapi"
+            request_headers.pop("accept", None)
 
         request_body = None
-        request_params = None
 
         if params is not None:
             request_params = urlencode({**params, **query_params})
         else:
             request_params = urlencode(query_params)
 
+        request_body = {}
         if body is not None:
             if content_type == "application/json":
                 request_body = json.dumps(body)
-
+            elif item in ["place_order"]:
+                request_body["jData"] = json.dumps(body)
             elif content_type == "application/x-www-form-urlencoded":
-                request_body = {"jData": json.dumps(body)}
+                request_body = urllib.parse.urlencode(  # type:ignore
+                    {"jData": json.dumps(body)},
+                    quote_via=urllib.parse.quote,  # type:ignore
+                )
 
         resp = None
         resp_data = None
@@ -431,17 +585,18 @@ class Kotak(Broker):
             resp = requests.get(url=url, params=request_params, headers=request_headers)
 
         elif method == "POST":
+            url += "?" + urlencode(query_params)
+
             resp = requests.post(
-                url=url,
+                url,
                 headers=request_headers,
-                data=request_body,
-                params=request_params,
+                data=request_body,  # type:ignore
             )
 
         if resp and resp.ok:
             resp_data = resp.json()
 
         if resp_data is None:
-            raise Exception("")
+            raise BrokerException("Request Failed: No response from Kotak server")
 
         return resp_data

{quantplay-2.0.151 → quantplay-2.0.161}/quantplay.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: quantplay
-Version: 2.0.151
+Version: 2.0.161
 Summary: This python package will be stored in AWS CodeArtifact
 Home-page: 
 Author: 

{quantplay-2.0.151 → quantplay-2.0.161}/setup.py

@@ -21,7 +21,7 @@ requirements = [
 setup(
     name="quantplay",
     long_description=Path("README.md").read_text(),
-    version="2.0.151",
+    version="2.0.161",
     setup_requires=["pytest-runner"],
     install_requires=requirements,
     tests_require=[],