quantplay 2.0.178__tar.gz → 2.0.181__tar.gz

{quantplay-2.0.178 → quantplay-2.0.181}/PKG-INFO

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

{quantplay-2.0.178 → quantplay-2.0.181}/quantplay/broker/broker_factory.py

@@ -182,6 +182,7 @@ class BrokerFactory:
 
         elif broker == Broker.KOTAK:
             broker_client = Kotak(
+                user_id=broker_data["user_id"],
                 consumer_key=broker_data["consumer_key"],
                 consumer_secret=broker_data["consumer_secret"],
                 mobilenumber=broker_data["mobilenumber"],
@@ -384,6 +385,7 @@ class BrokerFactory:
 
         elif broker == Broker.KOTAK:
             broker_client = Kotak(
+                user_id=broker_data["user_id"],
                 configuration=broker_data["configuration"],
                 otp=broker_data.get("otp"),
                 load_instrument=load_instrument,

{quantplay-2.0.178 → quantplay-2.0.181}/quantplay/broker/icici_direct.py

@@ -417,7 +417,7 @@ class ICICI(Broker):
         margins = self.invoke_wrapper(self.wrapper.get_funds)
 
         return {
-            "total_balance": margins["total_bank_balance"],
+            "total_balance": float(margins["total_bank_balance"]),
             "margin_available": (
                 float(margins["allocated_equity"])
                 + float(margins["allocated_fno"])
@@ -430,7 +430,7 @@ class ICICI(Broker):
                 + float(margins["block_by_trade_commodity"])
                 + float(margins["block_by_trade_currency"])
             ),
-            "cash": margins["unallocated_balance"],
+            "cash": float(margins["unallocated_balance"]),
         }
 
     def ltp(self, exchange: ExchangeType, tradingsymbol: str) -> float:

{quantplay-2.0.178 → quantplay-2.0.181}/quantplay/broker/kotak.py

@@ -10,6 +10,7 @@ import urllib
 import jwt
 
 from quantplay.broker.generics.broker import Broker
+from quantplay.broker.kotak_utils.kotak_ws import NeoWebSocket
 from quantplay.model.broker import (
     MarginsResponse,
     ModifyOrderRequest,
@@ -20,6 +21,7 @@ from quantplay.model.generics import (
     OrderTypeType,
     ProductType,
     TransactionType,
+    OrderStatusType,
 )
 from quantplay.model.order_event import OrderUpdateEvent
 from quantplay.exception.exceptions import (
@@ -40,6 +42,7 @@ class Kotak(Broker):
 
     def __init__(
         self,
+        user_id: str,
         order_updates: Queue[OrderUpdateEvent] | None = None,
         consumer_key: str | None = None,
         consumer_secret: str | None = None,
@@ -76,6 +79,8 @@ class Kotak(Broker):
 
         if load_instrument:
             self.load_instrument()
+        self.order_updates = order_updates
+        self.user_id = user_id
 
     def load_instrument(self, file_name: str | None = None) -> None:
         try:
@@ -573,6 +578,25 @@ class Kotak(Broker):
 
         return order_type_map.get(order_type, order_type)
 
+    def get_quantplay_order_type(self, order_type: str) -> OrderTypeType:
+        order_type_map: dict[str, str] = {
+            "L": "LIMIT",
+            "MKT": "MARKET",
+        }
+
+        return order_type_map.get(order_type, order_type)  # type:ignore
+
+    def get_quantplay_order_status(self, status: str) -> OrderStatusType:
+        if status in ["put order req received", "validation pending", "open pending"]:
+            return "OPEN"
+        if status == "cancel pending":
+            return "CANCELLED"
+        status = status.upper()
+        if status not in ["OPEN", "TRIGGER_PENDING", "CANCELLED", "REJECTED"]:
+            Constants.logger.error(f"{status} not supported for Kotak")
+            return "INVALID STATUS"  # type:ignore
+        return status  # type:ignore
+
     def get_exchange(self, exchange: ExchangeType) -> str:
         exchange_segment_map: dict[ExchangeType, str] = {
             "NSE": "nse_cm",
@@ -739,3 +763,51 @@ class Kotak(Broker):
             raise BrokerException("Request Failed: No response from Kotak server")
 
         return resp_data
+
+    def event_handler_order_update(self, order: dict[str, Any]):
+        if "data" not in order:
+            return
+        data = json.loads(order["data"])
+        if data["type"] != "order":
+            return
+        order = data["data"]
+
+        quantplay_order: OrderUpdateEvent = {
+            "placed_by": self.user_id,  # type:ignore
+            "tradingsymbol": order["trdSym"],
+            "exchange": self.get_quantplay_exchange(order["exSeg"]),
+            "tag": order["GuiOrdId"],
+            "order_id": order["nOrdNo"],
+            "exchange_order_id": order["exOrdId"],
+            "order_type": self.get_quantplay_order_type(order["prcTp"]),
+            "price": float(order["prc"]),
+            "quantity": int(order["qty"]),
+            "product": order["prod"],
+            "status": self.get_quantplay_order_status(order["ordSt"]),
+        }
+
+        if quantplay_order["exchange"] == "NSE":
+            quantplay_order["tradingsymbol"] = quantplay_order["tradingsymbol"].replace(
+                "-EQ", ""
+            )
+
+        quantplay_order["transaction_type"] = "BUY" if order["trnsTp"] == "B" else "SELL"
+        if "trgPrc" in order:
+            quantplay_order["trigger_price"] = float(order["trgPrc"])
+        else:
+            quantplay_order["trigger_price"] = None
+        print(quantplay_order)
+
+        if self.order_updates:
+            self.order_updates.put(quantplay_order)
+
+    def stream_order_data(self):
+        ws = NeoWebSocket(
+            sid=self.configuration.get("sid", ""),
+            token=self.configuration.get("edit_token", ""),
+            server_id=self.configuration.get("serverId", ""),
+        )
+        ws.on_message = self.event_handler_order_update
+        ws.on_error = lambda x: print(x)
+
+        ws.get_order_feed()

{quantplay-2.0.178 → quantplay-2.0.181}/quantplay/broker/noren.py

@@ -764,7 +764,7 @@ class Noren(Broker):
                 cash = 0
 
             margins: MarginsResponse = {
-                "margin_used": api_margins["margin_used"],
+                "margin_used": float(api_margins["margin_used"]),
                 "margin_available": margin_available,
                 "cash": cash,
                 "total_balance": float(cash) + float(holdings_val),

quantplay-2.0.181/quantplay/core/strategy.py

@@ -0,0 +1,193 @@
+from datetime import datetime
+import polars as pl
+import logging
+
+pl.Config.set_tbl_cols(10)
+
+
+class Strategy:
+    def __init__(self, name: str = "BaseStrategy") -> None:
+        self.index: str
+        self.type: str
+        self.exit_time: str
+        self.index: str
+
+        self.name = name
+        self.underlying_map = {"NIFTY BANK": "BANKNIFTY"}
+        self.data_source = "~/.quantplay"
+        self.symbol_expiry = pl.read_parquet(f"{self.data_source}/symbol_expiry.parquet")
+
+        logging.basicConfig(level=logging.INFO)
+
+        self.logger = logging.getLogger("testing")
+
+    def add_days_to_expiry(self, trades: pl.DataFrame) -> pl.DataFrame:
+        trades = trades.join(self.symbol_expiry, on=["symbol"], how="left")
+        trades = trades.with_columns(
+            pl.col("expiry")
+            .sub(pl.col("date_only"))
+            .dt.total_days()
+            .alias("days_to_expiry")
+        )
+
+        return trades
+
+    def backtest(self, trades: pl.DataFrame):
+        """
+        Backtest the strategy using historical data.
+
+        Parameters:
+            data (pl.DataFrame): Historical OHLC data.
+
+        Returns:
+            pl.DataFrame: DataFrame containing signals and performance metrics.
+        """
+        underlying_name = self.underlying_map[self.index]
+        opt_data = pl.read_parquet(
+            f"{self.data_source}/RAW/OPT/{underlying_name}.parquet"
+        )
+
+        if self.type == "intraday":
+            trades = trades.select(
+                [
+                    "date",
+                    "date_only",
+                    "underlying_price",
+                    "symbol",
+                    "close",
+                ]
+            ).rename({"close": "entry_price", "date": "entry_time"})
+
+            market_data = (
+                opt_data.filter(
+                    pl.col("date")
+                    .dt.time()
+                    .eq(datetime.strptime(self.exit_time, "%H:%M").time())
+                )
+                .select(["symbol", "date", "close"])
+                .with_columns(pl.col("date").dt.date().alias("date_only"))
+                .rename({"close": "exit_price", "date": "exit_time"})
+            )
+
+            bt_trades = trades.join(market_data, on=["date_only", "symbol"], how="left")
+            bt_trades = bt_trades.with_columns(
+                (pl.col("exit_price").sub(pl.col("entry_price")).alias("pnl"))
+            ).select(
+                [
+                    "symbol",
+                    "entry_time",
+                    "exit_time",
+                    "entry_price",
+                    "exit_price",
+                    "pnl",
+                ]
+            )
+
+            print(bt_trades)
+            print(bt_trades.select(pl.col("exit_price").sub(pl.col("entry_price"))).sum())
+            bt_trades.write_parquet(f"./out/{self.name}.parquet")
+
+        elif self.type == "overnight":
+            trades = (
+                trades.with_columns(
+                    pl.col("date_only")
+                    .add(
+                        pl.when(pl.col("date_only").dt.weekday().eq(5))
+                        .then(pl.duration(days=3))
+                        .when(pl.col("date_only").dt.weekday().eq(6))
+                        .then(pl.duration(days=2))
+                        .otherwise(pl.duration(days=1))
+                    )
+                    .alias("next_day")
+                )
+                .select(
+                    [
+                        "date",
+                        "next_day",
+                        "date_only",
+                        "underlying_price",
+                        "symbol",
+                        "close",
+                    ]
+                )
+                .rename({"close": "entry_price", "date": "entry_time"})
+            )
+
+            market_data = (
+                opt_data.filter(pl.col("date").dt.time().eq(pl.time(9, 30, 0)))
+                .select(["symbol", "date", "close"])
+                .with_columns(pl.col("date").dt.date().alias("next_day"))
+                .rename({"close": "exit_price", "date": "exit_time"})
+            )
+
+            bt_trades = trades.join(market_data, on=["next_day", "symbol"], how="left")
+
+            bt_trades = bt_trades.with_columns(
+                (pl.col("exit_price").sub(pl.col("entry_price")).alias("pnl"))
+            ).select(
+                [
+                    "symbol",
+                    "entry_time",
+                    "exit_time",
+                    "entry_price",
+                    "exit_price",
+                    "pnl",
+                ]
+            )
+
+            print(bt_trades)
+            print(bt_trades.select(pl.col("exit_price").sub(pl.col("entry_price"))).sum())
+
+            bt_trades.write_parquet(f"./out/{self.name}.parquet")
+
+    def calculate_performance(self, data: pl.DataFrame) -> pl.DataFrame:
+        """
+        Calculate performance metrics based on signals.vv
+
+        Parameters:
+            data (pl.DataFrame): DataFrame with signals.
+
+        Returns:
+            pl.DataFrame: DataFrame with performance metrics.
+        """
+        # Implement performance calculation
+        raise NotImplementedError("Please implement the calculate_performance method.")
+
+    def load_data(self) -> None:
+        self.logger.info("Loading data")
+        # Load data based on the provided data format
+
+        index_data = pl.read_parquet(
+            f"{self.data_source}/NSE/INDICES/minute/{self.index}.parquet"
+        )
+        underlying_name = self.underlying_map[self.index]
+        opt_data = pl.read_parquet(
+            f"{self.data_source}/RAW/OPT/{underlying_name}.parquet"
+        )
+        self.data = {"index_data": index_data, "opt_data": opt_data}
+        self.logger.info("Data loaded successfully ....")
+
+    def run_backtest(self, **kwargs: ...):
+        """
+        Run backtest for a given strategy by loading data internally.
+
+        Parameters:
+            strategy (Strategy): An instance of a Strategy subclass.
+            **kwargs: Additional keyword arguments for data loading.
+
+        Returns:
+            pl.DataFrame: DataFrame with backtest results.
+        """
+        # Set up logging
+
+        try:
+            self.load_data()
+            trades = self.generate_signals(self.data)
+            self.backtest(trades)
+
+            self.logger.info("Backtest completed successfully.")
+        except Exception as e:
+            self.logger.error(f"An error occurred during backtest: {e}")
+            raise
+
+    def generate_signals(self, data: dict[str, pl.DataFrame]) -> pl.DataFrame: ...

quantplay-2.0.181/quantplay/indicator/iv.py

@@ -0,0 +1,37 @@
+from py_vollib.black_scholes.implied_volatility import implied_volatility  # type:ignore
+from datetime import date, datetime, time
+from typing import Literal
+
+
+class ImpliedVolatility:
+    @staticmethod
+    def get_option_type(option_type: Literal["CE", "PE"]) -> Literal["c", "p"]:
+        if option_type == "CE":
+            return "c"
+
+        elif option_type == "PE":
+            return "p"
+
+    @staticmethod
+    def time_to_expiry(expiry: date, tick_time: float) -> float:
+        expiry_dt = datetime.combine(date=expiry, time=time(15, 30, 0, 0))
+        time_to_expiry = (expiry_dt.timestamp() - tick_time) / 31536000
+
+        return time_to_expiry
+
+    @staticmethod
+    def iv(
+        option_price: float,
+        strike: int,
+        option_type: Literal["CE", "PE"],
+        underlying_price: float,
+        tte: float,
+    ) -> float:
+        rate_of_interest = 0.1
+
+        return (
+            implied_volatility(  # type:ignore
+                option_price, underlying_price, strike, tte, rate_of_interest, option_type
+            )
+            * 100
+        )

quantplay-2.0.181/quantplay/strategy/iv_spike.py

@@ -0,0 +1,93 @@
+import polars as pl
+from datetime import time
+
+from quantplay.core.strategy import Strategy
+from quantplay.indicator.iv import ImpliedVolatility
+
+
+class IVSpike(Strategy):
+    def __init__(self) -> None:
+        super().__init__(name="iv_spike")
+        self.type = "intraday"
+        self.exit_time = "15:10"
+        self.index = "NIFTY BANK"
+
+    def generate_signals(self, data: dict[str, pl.DataFrame]) -> pl.DataFrame:
+        """
+        Generate signals based on below logic
+        """
+        index_data = data["index_data"]
+        opt_data = data["opt_data"]
+
+        index_data = index_data.with_columns(pl.col("close").alias("underlying_price"))
+
+        opt_data = opt_data.with_columns(pl.col("date").dt.date().alias("date_only"))
+        opt_data = self.add_days_to_expiry(opt_data)
+
+        opt_data = opt_data.filter(pl.col("days_to_expiry").lt(2))
+        opt_data = opt_data.join(
+            index_data["date", "underlying_price"],
+            on=["date"],
+            how="left",
+        )
+        opt_data = opt_data.filter(
+            pl.col("date").dt.time() <= pl.time(hour=14, minute=45)
+        )
+        opt_data = opt_data.filter(pl.col("date").dt.year() >= 2024)
+        opt_data = opt_data.filter(pl.col("date").dt.month() >= 8)
+        print(len(opt_data))
+
+        opt_data = opt_data.with_columns(
+            pl.col("symbol")
+            .str.extract(r"[A-Z]+[0-9]{2}.{3}([0-9]+)[P|C]E")
+            .cast(pl.Float64)
+            .alias("strike"),
+            pl.col("symbol")
+            .str.extract(r"[A-Z]+[0-9]{2}.{3}[0-9]+([P|C])E")
+            .str.to_lowercase()
+            .alias("option_type"),
+            (
+                (pl.col("expiry").dt.combine(time(15, 30, 0)).dt.timestamp("ms"))
+                .sub(pl.col("date").dt.timestamp("ms"))
+                .truediv(31536000000)
+            ).alias("tte"),
+        )
+
+        opt_data = opt_data.with_columns(
+            pl.struct(
+                [
+                    "close",
+                    "strike",
+                    "option_type",
+                    "underlying_price",
+                    "tte",
+                ]
+            )
+            .map_elements(
+                lambda x: int(
+                    ImpliedVolatility.iv(
+                        x["close"],
+                        x["strike"],
+                        x["option_type"],
+                        x["underlying_price"],
+                        x["tte"],
+                    )
+                ),
+                return_dtype=pl.Float64,
+            )
+            .alias("iv")
+        )
+
+        trades = opt_data
+        trades = trades.filter(pl.col("iv") > 40).filter(
+            pl.col("close").sub(30).abs().rank("dense").eq(1).over("date_only")
+        )
+
+        trades = trades.with_columns(pl.lit("SELL").alias("transaction_type"))
+        print(trades)
+        return trades
+
+
+if __name__ == "__main__":
+    self = IVSpike()
+    self.run_backtest()

quantplay-2.0.181/quantplay/strategy/obuy.py

@@ -0,0 +1,51 @@
+import polars as pl
+
+from quantplay.core.strategy import Strategy
+
+
+class OvernightOptionBuy(Strategy):
+    def __init__(self) -> None:
+        super().__init__(name="OBuy")
+        self.type = "overnight"
+        self.exit_time = "09:30"
+        self.index = "NIFTY BANK"
+
+    def generate_signals(self, data: dict[str, pl.DataFrame]) -> pl.DataFrame:
+        """
+        Generate signals based on below logic
+        """
+        index_data = data["index_data"]
+        opt_data = data["opt_data"]
+
+        index_data = index_data.filter(
+            pl.col("date").dt.time() >= pl.time(hour=9, minute=30)
+        )
+        index_data = index_data.with_columns(pl.col("date").dt.date().alias("date_only"))
+        index_data = index_data.with_columns(
+            pl.col("close").cum_max().over("date_only").alias("intraday_high")
+        )
+        index_data = index_data.filter(
+            (pl.col("date").dt.time() >= pl.time(hour=13, minute=30))
+            & (pl.col("close") >= pl.col("intraday_high"))
+        )
+        trades = index_data.group_by("date_only").agg(pl.all().first())
+        trades = trades.with_columns(pl.col("close").alias("underlying_price"))
+
+        trades = trades[["date", "date_only", "underlying_price"]].join(
+            opt_data,
+            on=["date"],
+            how="left",
+        )
+
+        trades = self.add_days_to_expiry(trades)
+
+        trades = trades.filter(
+            (pl.col("days_to_expiry") < 7) & pl.col("days_to_expiry").gt(3)
+        ).filter(pl.col("close").sub(700).abs().rank("dense").eq(1).over("date_only"))
+
+        return trades
+
+
+if __name__ == "__main__":
+    self = OvernightOptionBuy()
+    self.run_backtest()

{quantplay-2.0.178 → quantplay-2.0.181}/quantplay/wrapper/redis.py

@@ -39,8 +39,8 @@ class Redis:
 
         Redis.__instance = self
 
-    def get(self, key: str) -> None:
+    def get(self, key: int) -> None:
         if self.error:
             return None
 
-        return self.redis_client.get(str(key))  # type: ignore
+        return self.redis_client.get(f"mkt:{key}")  # type: ignore

{quantplay-2.0.178 → quantplay-2.0.181}/quantplay.egg-info/PKG-INFO

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

{quantplay-2.0.178 → quantplay-2.0.181}/quantplay.egg-info/SOURCES.txt

@@ -43,14 +43,21 @@ quantplay/broker/xts_utils/Connect.py
 quantplay/broker/xts_utils/Exception.py
 quantplay/broker/xts_utils/InteractiveSocketClient.py
 quantplay/broker/xts_utils/__init__.py
+quantplay/core/__init__.py
+quantplay/core/strategy.py
 quantplay/exception/__init__.py
 quantplay/exception/exceptions.py
+quantplay/indicator/__init__.py
+quantplay/indicator/iv.py
 quantplay/model/__init__.py
 quantplay/model/broker.py
 quantplay/model/broker_response.py
 quantplay/model/generics.py
 quantplay/model/instrument_data.py
 quantplay/model/order_event.py
+quantplay/strategy/__init__.py
+quantplay/strategy/iv_spike.py
+quantplay/strategy/obuy.py
 quantplay/utils/__init__.py
 quantplay/utils/caching.py
 quantplay/utils/constant.py

{quantplay-2.0.178 → quantplay-2.0.181}/setup.py

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