quantplay 1.2.87__tar.gz → 1.2.91__tar.gz

{quantplay-1.2.87 → quantplay-1.2.91}/PKG-INFO

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

{quantplay-1.2.87 → quantplay-1.2.91}/quantplay/broker/generics/broker.py

@@ -342,7 +342,7 @@ class Broker():
 
         return option_symbol
 
-    def exit_all_trigger_orders(self, tag="ALL", symbol_contains=None, order_timestamp=None):
+    def exit_all_trigger_orders(self, tag="ALL", symbol_contains=None, order_timestamp=None, modify_sleep_time=10):
         stoploss_orders = self.orders()
         stoploss_orders = stoploss_orders[stoploss_orders.status == "TRIGGER PENDING"]
 
@@ -382,7 +382,7 @@ class Broker():
             self.modify_order(stoploss_order)
             time.sleep(.1)
 
-        self.modify_orders_till_complete(orders_to_close)
+        self.modify_orders_till_complete(orders_to_close, sleep_time=modify_sleep_time)
         Constants.logger.info("All order have been closed successfully")
 
     def square_off_all(self, dry_run=True, contains=None, sleep_time=0.1):

{quantplay-1.2.87 → quantplay-1.2.91}/quantplay/broker/xts.py

@@ -504,10 +504,10 @@ class XTS(Broker):
             elif new_ord["exchange"] == "NSECM":
                 new_ord["exchange"] = "NSE"
 
-            if new_ord["exchange"] in ["NFO", "MCX"]:
-                new_ord["tradingsymbol"] = self.broker_symbol_map[
-                    order["tradingsymbol"]
-                ]
+            # if new_ord["exchange"] in ["NFO", "MCX"]:
+            #     new_ord["tradingsymbol"] = self.broker_symbol_map[
+            #         order["tradingsymbol"]
+            #     ]
 
             new_ord["order_type"] = order["OrderType"].upper()
             new_ord["product"] = order["ProductType"].upper()

{quantplay-1.2.87 → quantplay-1.2.91}/quantplay/services/market.py

@@ -26,12 +26,15 @@ class Market:
 
     def __init__(self):
         config = QuantplayConfig.get_config()
+        self.base_path = "{}/.quantplay/".format(expanduser("~"))
         self.nse_equity_path = "{}/.quantplay/NSE_EQ/".format(expanduser("~"))
         self.nse_opt_path = "{}/.quantplay/NSE_OPT/".format(expanduser("~"))
         self.nse_fut_path = "{}/.quantplay/NSE_FUT/".format(expanduser("~"))
         self.nse_market_data_path = "{}/.quantplay/NSE_MARKET_DATA/".format(expanduser("~"))
         self.mcx_path = "{}/.quantplay/MCX/".format(expanduser("~"))
 
+        if "DEFAULT" in config and "base_path" in config["DEFAULT"]:
+            self.base_path = config["DEFAULT"]["base_path"]
         if "DEFAULT" in config and "nse_equity_path" in config["DEFAULT"]:
             self.nse_equity_path = config["DEFAULT"]["nse_equity_path"]
         if "DEFAULT" in config and "nse_opt_path" in config["DEFAULT"]:

{quantplay-1.2.87 → quantplay-1.2.91}/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.87 → quantplay-1.2.91}/quantplay.egg-info/PKG-INFO

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

{quantplay-1.2.87 → quantplay-1.2.91}/setup.py

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