quantplay 1.2.89__tar.gz → 1.2.92__tar.gz

{quantplay-1.2.89 → quantplay-1.2.92}/PKG-INFO

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

{quantplay-1.2.89 → quantplay-1.2.92}/quantplay/broker/iifl_xts.py

@@ -14,5 +14,5 @@ class IIFL(XTS):
             root_interactive=self.xts_interactive,
             root_market=self.xts_market,
             wrapper=wrapper,
-            ClientID=ClientID
+            ClientID=ClientID,
         )

{quantplay-1.2.89 → quantplay-1.2.92}/quantplay/broker/xts.py

@@ -5,6 +5,7 @@ import pandas as pd
 import numpy as np
 import pickle
 import codecs
+from datetime import datetime
 
 from quantplay.broker.generics.broker import Broker
 from quantplay.utils.constant import Constants, timeit, OrderType
@@ -65,6 +66,7 @@ class XTS(Broker):
         )
 
     def initialize_symbol_data(self):
+        # TODO: Check for Futures
         try:
             self.symbol_data = PickleUtils.load_data("xts_instruments")
             Constants.logger.info("[LOADING_INSTRUMENTS] loading data from cache")
@@ -78,8 +80,29 @@ class XTS(Broker):
             for instrument in instruments:
                 exchange = instrument["exchange"]
                 tradingsymbol = instrument["tradingsymbol"]
+                # NIFTY 08JUN2023 PE 17850 <- NIFTY2360817850PE
+                # 2023-06-27 -> 08JUN2023
+                # For FUTURES : EURINR23AUGFUT -> EURINR 23AUG2023 FUT
+                
+                ins_type = instrument["instrument_type"]
+                name = instrument["name"]
+                if ins_type in ["CE","PE"]:
+                    expiry  = datetime.strftime(datetime.strptime(str(instrument["expiry"]), "%Y-%m-%d"), "%d%b%Y").upper()
+                    strike = str(instrument["strike"]).rstrip("0")
+                    if strike[-1] == ".":
+                        strike = strike[:-1]
+                    instrument["broker_symbol"] = f"{name} {expiry} {ins_type} {strike}"
+                elif ins_type == "FUT":
+                    expiry  = datetime.strftime(datetime.strptime(str(instrument["expiry"]), "%Y-%m-%d"), "%d%b%Y").upper()
+                    instrument["broker_symbol"] = f"{name} {expiry} FUT"
+                else:
+                    instrument["broker_symbol"] = tradingsymbol
+                    
+
                 self.symbol_data["{}:{}".format(exchange, tradingsymbol)] = instrument
 
+            self.initialize_broker_symbol_map()
+
             PickleUtils.save_data(self.symbol_data, "xts_instruments")
             Constants.logger.info("[LOADING_INSTRUMENTS] loading data from server")
 

{quantplay-1.2.89 → quantplay-1.2.92}/quantplay/services/tradelens.py

@@ -4,9 +4,12 @@ import pandas as pd
 from quantplay.reporting.visuals import VisualReport
 from quantplay.services.market import Market
 import matplotlib.pyplot as plt
+import inspect
+import typing
 
 market = Market()
 
+
 class TradeLens:
 
     @staticmethod
@@ -29,8 +32,10 @@ class TradeLens:
 
         for j in range(0, 5):
             temp_df.loc[:, 'balance'] = temp_df.profit.cumsum()
-            temp_df.loc[:, 'running_max_balance'] = np.maximum.accumulate(temp_df.balance)
-            temp_df.loc[:, 'drawdowns'] = temp_df.running_max_balance - temp_df.balance
+            temp_df.loc[:, 'running_max_balance'] = np.maximum.accumulate(
+                temp_df.balance)
+            temp_df.loc[:, 'drawdowns'] = temp_df.running_max_balance - \
+                temp_df.balance
 
             max_drawdown = np.max(temp_df.drawdowns)
             end_index = None
@@ -41,7 +46,7 @@ class TradeLens:
 
                 start_index = end_index
                 while temp_df.iloc[start_index - 1]['running_max_balance'] == temp_df.iloc[start_index][
-                    'running_max_balance']:
+                        'running_max_balance']:
                     start_index = start_index - 1
 
                 print("Max drawdown {} from {} till {} amount {}".format(j,
@@ -56,7 +61,8 @@ class TradeLens:
     def analyse(trades, disable_metrics=[]):
         trades.loc[:, 'date'] = pd.to_datetime(trades.date)
         exchanges = list(trades.exchange.unique())
-        trades.loc[:, 'segment'] = np.where("PE" == trades.tradingsymbol.str[-2:], "PE", "CE")
+        trades.loc[:, 'segment'] = np.where(
+            "PE" == trades.tradingsymbol.str[-2:], "PE", "CE")
 
         trades.loc[:, 'hour'] = trades.date.dt.hour
         trades.loc[:, "day_of_week"] = trades.date.dt.day_name()
@@ -85,18 +91,21 @@ class TradeLens:
             print("Trade return by time")
             print(trades.groupby('time').trade_return.mean())
 
-        trades.loc[:, 'trade_return'] = trades.close_price / trades.entry_price - 1
+        trades.loc[:, 'trade_return'] = trades.close_price / \
+            trades.entry_price - 1
         print("Mean return of trades")
         print(trades.trade_return.mean())
 
-        trades.loc[:, 'week_number'] = (trades.order_timestamp.dt.day / 7).astype(int)
+        trades.loc[:, 'week_number'] = (
+            trades.order_timestamp.dt.day / 7).astype(int)
         if "week_number" not in disable_metrics:
             print("profit by week number")
             print(trades.groupby('week_number').profit.mean())
 
     @staticmethod
     def show_report(trades):
-        trades.loc[:, 'order_timestamp'] = pd.to_datetime(trades.order_timestamp)
+        trades.loc[:, 'order_timestamp'] = pd.to_datetime(
+            trades.order_timestamp)
         VisualReport.display_profit_report(trades)
         VisualReport.display_balance_report(trades, 'tt')
 
@@ -106,7 +115,8 @@ class TradeLens:
         symbols_by_security_type = {}
         for security_type in security_types:
             symbols_by_security_type[security_type] = list(
-                trades[trades.security_type == security_type].tradingsymbol.unique()
+                trades[trades.security_type ==
+                       security_type].tradingsymbol.unique()
             )
 
         market_data = market.data(
@@ -130,7 +140,8 @@ class TradeLens:
             testing = pd.concat([testing, t_df])
         testing = testing.sort_values(["symbol", "date"])
         testing.loc[:, 'date_only'] = pd.to_datetime(testing.date.dt.date)
-        testing.loc[:, 'pnl'] = testing.groupby(['symbol', 'date_only']).pnl.ffill()
+        testing.loc[:, 'pnl'] = testing.groupby(
+            ['symbol', 'date_only']).pnl.ffill()
 
         testing = testing.groupby('date').pnl.sum().reset_index()
 
@@ -138,8 +149,8 @@ class TradeLens:
             plt.plot(testing.date, testing.pnl)
             plt.show(block=True)
         return {
-            "minimum_pnl" : int(testing.pnl.min()),
-            "maximum_pnl" : int(testing.pnl.max())
+            "minimum_pnl": int(testing.pnl.min()),
+            "maximum_pnl": int(testing.pnl.max())
         }
 
     @staticmethod
@@ -163,11 +174,11 @@ class TradeLens:
         trade_data = trade_data[trade_data.date < trade_data.closing_timestamp]
         trade_data.loc[:, 'close'] = np.where(
             ((trade_data.transaction_type == "SELL") & (trade_data.close > trade_data.close_price) & (
-                        trade_data.date >= trade_data.closing_timestamp)),
+                trade_data.date >= trade_data.closing_timestamp)),
             trade_data.close_price, trade_data.close)
         trade_data.loc[:, 'close'] = np.where(
             ((trade_data.transaction_type == "BUY") & (trade_data.close < trade_data.close_price) & (
-                        trade_data.date >= trade_data.closing_timestamp)),
+                trade_data.date >= trade_data.closing_timestamp)),
             trade_data.close_price, trade_data.close)
         trade_data.loc[:, 'pnl'] = np.where(trade_data.transaction_type == "SELL",
                                             trade_data.entry_price - trade_data.close,
@@ -180,10 +191,103 @@ class TradeLens:
             date_only = str(check_date).split("T")[0]
             response = TradeLens.plot_pnl(trade_data, date_only)
             trade_analysis.append({
-                "date_only" : date_only,
-                "backtesting_pnl" : trades[trades.date_only.astype(str) == date_only].profit.sum(),
-                "minimum_pnl" : response["minimum_pnl"]
+                "date_only": date_only,
+                "backtesting_pnl": trades[trades.date_only.astype(str) == date_only].profit.sum(),
+                "minimum_pnl": response["minimum_pnl"]
             })
 
         return pd.DataFrame(trade_analysis)
 
+    def alpha_runner(alpha: typing.Callable, day_candles: pd.DataFrame):
+        """
+        Passes Required Parameters to the alpha function
+        """
+        return alpha(
+            open=day_candles.open,
+            low=day_candles.low,
+            high=day_candles.high,
+            close=day_candles.close,
+            volume=day_candles.volume,
+            vwap=day_candles.vwap,
+            returns=day_candles.returns,
+            adv5=day_candles.adv5,
+            adv10=day_candles.adv10,
+            adv15=day_candles.adv15,
+            adv20=day_candles.adv20,
+            adv30=day_candles.adv30,
+            adv40=day_candles.adv40,
+            adv50=day_candles.adv50,
+            adv60=day_candles.adv60,
+            adv81=day_candles.adv81,
+            adv120=day_candles.adv120,
+            adv150=day_candles.adv150,
+            adv180=day_candles.adv180,
+        )
+
+
+    @staticmethod
+    def validate_alpha(self, day_candles, alpha, num_buckets=10):
+        """Validate alphas by bucketing them into 10 buckets and checking the returns
+
+        Args:
+            day_candles (DataFrame): Dataframe containing day candles
+            alpha (Function): function for calculating alpha
+            num_buckets (int, optional): No of brackets required. Defaults to 10.
+        """
+        try:
+            alpha_name = alpha.__name__
+            alpha_bucket_name = "{}_bucket".format(alpha_name)
+
+            alpha_candles = day_candles[["date"]]
+
+            alpha_candles.loc[:, alpha_name] = self.alpha_runner(alpha=alpha, day_candles=day_candles)
+            
+            
+            alpha_candles.loc[:, f"{alpha_name}_rank"] = alpha_candles.groupby("date")[
+                alpha_name
+            ].rank(ascending=False)
+
+            alpha_candles.loc[:, "is_top500"] = np.where(
+                (alpha_candles[f"{alpha_name}_rank"] <= 500), True, False
+            )
+
+            alpha_candles.loc[:, "intraday_return"] = (
+                day_candles.close / day_candles.open - 1
+            )
+            alpha_candles.loc[
+                :, "next_day_intraday_return"
+            ] = alpha_candles.intraday_return.shift(-1)
+
+            alpha_candles.loc[:, alpha_bucket_name] = 1 + 10 * alpha_candles.groupby(
+                ["is_top500", "date"]
+            )[alpha_name].rank(method="first", pct=True)
+
+            alpha_candles.loc[:, alpha_bucket_name] = np.where(
+                alpha_candles["is_top500"] == False,
+                np.nan,
+                alpha_candles[alpha_bucket_name],
+            )
+
+            alpha_candles.loc[:, alpha_bucket_name] = (
+                alpha_candles[alpha_bucket_name]
+                .replace([np.inf, -np.inf, np.nan], 0)
+                .astype(int)
+                .replace([0], np.nan)
+                .replace([num_buckets + 1], num_buckets)
+            )
+
+            # plotting
+            t_df = (
+                alpha_candles.groupby(alpha_bucket_name)
+                .next_day_intraday_return.mean()
+                .reset_index()
+            )
+
+            plt.clf()
+            plt.title(alpha_name)
+            plt.bar(t_df[alpha_bucket_name], -1 *
+                    t_df.next_day_intraday_return)
+            plt.show()
+
+        except Exception as e:
+            print(alpha, inspect.signature(alpha), e)

{quantplay-1.2.89 → quantplay-1.2.92}/quantplay.egg-info/PKG-INFO

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

{quantplay-1.2.89 → quantplay-1.2.92}/setup.py

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