sysstra 0.1.2.2__tar.gz → 0.1.2.4__tar.gz

{sysstra-0.1.2.2 → sysstra-0.1.2.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: sysstra
-Version: 0.1.2.2
+Version: 0.1.2.4
 Summary: Official Python Library for Sysstra Algo Trading
 Home-page: https://github.com/sysstra/sysstra
 Author: Anurag Singh Kushwah

{sysstra-0.1.2.2 → sysstra-0.1.2.4}/setup.py

@@ -2,7 +2,7 @@ from setuptools import setup, find_packages
 
 setup(
     name="sysstra",
-    version="0.1.2.2",
+    version="0.1.2.4",
     description="Official Python Library for Sysstra Algo Trading",
     long_description=open("README.md").read(),
     long_description_content_type="text/markdown",

{sysstra-0.1.2.2 → sysstra-0.1.2.4}/sysstra/custom_indicators.py

@@ -875,14 +875,24 @@ def bollinger_bandwidth(dataframe, length=20, source="close", std_dev=2, he_leng
         pass
 
 
-def calculate_bbw_range(dataframe, length, deviation=0.02):
+def calculate_bbw_range(dataframe, length=50, source="close", std_dev=2, deviation=0.02, ma_length=5):
     """ Function to calculate Bollinger Band Range"""
     try:
-        df = dataframe.copy()
-        df["bbw_ma"] = round(ta.sma(df["bbw"], length), 2)
-        df["bbw_diff"] = abs(round(df["bbw"] - df["bbw_ma"], 2))
-        df["bbw_range"] = np.where(df["bbw_diff"] > deviation, False, True)
-        return df[['bbw_range']]
+        basis = ta.sma(dataframe[source], length)
+        dev = std_dev * ta.stdev(dataframe[source], length)
+        upper = basis + dev
+        lower = basis - dev
+        bbw = ((upper - lower) / basis) * 100
+        bbw_ma = round(ta.sma(bbw, ma_length), 2)
+        bbw_diff = abs(round(bbw - bbw_ma, 2))
+        bbw_range = np.where(bbw_diff > deviation, False, True)
+
+        return bbw_range
+        # df = dataframe.copy()
+        # df["bbw_ma"] = round(TA.sma(df["bbw"], length), 2)
+        # df["bbw_diff"] = abs(round(df["bbw"] - df["bbw_ma"], 2))
+        # df["bbw_range"] = np.where(df["bbw_diff"] > deviation, False, True)
+        # return df[['bbw_range']]
     except Exception as e:
         print(f"Exception in calculating BB Range : {e}")
         pass
@@ -901,3 +911,111 @@ def calculate_tsi(close, period=14):
         print(f"Exception in calculating TSI : {e}")
         pass
 
+
+def calculate_orb(dataframe, start_time, end_time):
+    """ Function to Calculate ORB """
+    try:
+        print("Calculating ORB")
+        filtered_df = dataframe[
+            (dataframe['timestamp'].dt.time >= pd.to_datetime(start_time).time()) &
+            (dataframe['timestamp'].dt.time <= pd.to_datetime(end_time).time())
+            ]
+        orb_up = filtered_df["high"].max()
+        orb_down = filtered_df["low"].min()
+        return orb_up, orb_down
+    except Exception as e:
+        print(f"Exception in Calculating ORB : {e}")
+        pass
+
+
+def calculate_chop_zone(dataframe, periods=30):
+    """ Function to Calculate Chop Zone """
+    try:
+        print("Calculating Chop Zone")
+
+        df = dataframe.copy()
+
+        # Calculations
+        df['hlc3'] = (df['high'] + df['low'] + df['close']) / 3
+        pi = np.pi
+
+        df['highestHigh'] = df['high'].rolling(window=periods).max()
+        df['lowestLow'] = df['low'].rolling(window=periods).min()
+        df['span'] = 25 / (df['highestHigh'] - df['lowestLow']) * df['lowestLow']
+
+        df['ema34'] = df['close'].ewm(span=34, adjust=False).mean()
+
+        x1_ema34 = 0
+        x2_ema34 = 1
+        df['y1_ema34'] = 0
+        df['y2_ema34'] = (df['ema34'].shift(1) - df['ema34']) / df['hlc3'] * df['span']
+        df['c_ema34'] = np.sqrt((x2_ema34 - x1_ema34)**2 + (df['y2_ema34'] - df['y1_ema34'])**2)
+
+        df['emaAngle_1'] = np.round(180 * np.arccos((x2_ema34 - x1_ema34) / df['c_ema34']) / pi)
+        df['emaAngle'] = np.where(df['y2_ema34'] > 0, -df['emaAngle_1'], df['emaAngle_1'])
+
+        # Color logic
+        def get_chop_zone_color(angle):
+            if angle >= 5:
+                return "blue"
+            elif 3.57 <= angle < 5:
+                return "dark_green"
+            elif 2.14 <= angle < 3.57:
+                return "pale_green"
+            elif 0.71 <= angle < 2.14:
+                return "lime"
+            elif angle <= -5:
+                return "dark_red"
+            elif -5 < angle <= -3.57:
+                return "red"
+            elif -3.57 < angle <= -2.14:
+                return "orange"
+            elif -2.14 < angle <= -0.71:
+                return "light_orange"
+            else:
+                return "yellow"
+
+        df['chop_zone_color'] = df['emaAngle'].apply(get_chop_zone_color)
+
+        return df[['chop_zone_color']]
+    except Exception as e:
+        print(f"Exception in Calculating Chop Zone : {e}")
+        pass
+
+
+def smoothed_bbw(dataframe, length=20, source="close", std_dev=2, ma_type="sma", ma_length=5):
+    """ Function to Calculate Smoothed BBW """
+    try:
+        print("Calculating Smoothed BBW")
+        basis = TA.sma(dataframe[source], length)
+        # dev = std_dev * TA.stdev(dataframe[source], length)
+        upper = basis + std_dev * ta.stdev(dataframe[source], length)
+        lower = basis - std_dev * ta.stdev(dataframe[source], length)
+        bbw = (upper - lower) / basis * 100
+        if ma_type == "ema":
+            smoothed_bbw_1 = ta.ema(bbw, ma_length)
+            smoothed_bbw_2 = ta.ema(smoothed_bbw_1, ma_length)
+        else:
+            smoothed_bbw_1 = ta.sma(bbw, ma_length)
+            smoothed_bbw_2 = ta.sma(smoothed_bbw_1, ma_length)
+        output_df = pd.DataFrame()
+        output_df["bbw"] = bbw
+        output_df["sbbw"] = smoothed_bbw_2
+        output_df["sbbw_slope"] = np.where(output_df["sbbw"] - output_df["sbbw"].shift(1) > 0, "+ve", "-ve")
+        return output_df[["bbw", "sbbw", "sbbw_slope"]]
+    except Exception as e:
+        print(f"Exception in calculating Smoothed BBW : {e}")
+        pass
+
+
+def calculate_slope(dataframe, source):
+    """ Function to Calculate Slope """
+    try:
+        print("Calculating Slope")
+        output_df = dataframe.copy()
+        output_df[f"{source}_slope"] = np.where(output_df[source] - output_df[source].shift(1) > 0, "+ve", "-ve")
+        return output_df[[f"{source}_slope"]]
+    except Exception as e:
+        print(f"Exception in Calculating {source} Slope : {e}")
+        pass
+

{sysstra-0.1.2.2 → sysstra-0.1.2.4}/sysstra/utils.py

@@ -713,6 +713,15 @@ def apply_indicators(dataframe, indicators_dict, logger=None):
                                          lc_length=indicators_dict["BBW"]["lc_length"])
             dataframe["bbw"] = round(bbw_df, 2).fillna(0).values
 
+        if "SBBW" in indicators_dict:
+            sbbw_df = smoothed_bbw(dataframe=dataframe, length=indicators_dict["SBBW"]["length"],
+                                   std_dev=indicators_dict["SBBW"]["std_dev"], source=indicators_dict["SBBW"]["source"],
+                                   ma_type=indicators_dict["SBBW"]["ma_type"],
+                                   ma_length=indicators_dict["SBBW"]["ma_length"])
+            dataframe["bbw"] = round(sbbw_df.iloc[:, 0].fillna(0), 2).values
+            dataframe["sbbw"] = round(sbbw_df.iloc[:, 1].fillna(0), 2).values
+            dataframe["sbbw_slope"] = sbbw_df.iloc[:, 2].fillna(0).values
+
         if "BBWRANGE" in indicators_dict:
             bbw_range = calculate_bbw_range(dataframe=dataframe, length=indicators_dict["BBWRANGE"]["length"], deviation=indicators_dict["BBWRANGE"]["deviation"])
             dataframe["bbw_range"] = bbw_range
@@ -721,6 +730,24 @@ def apply_indicators(dataframe, indicators_dict, logger=None):
             tsi_df = calculate_tsi(close=dataframe["close"], period=indicators_dict["TSI"]["period"])
             dataframe["tsi"] = round(tsi_df, 2).fillna(0).values
 
+        if "COPPOCK" in indicators_dict:
+            coppock_df = ta.coppock(close=dataframe["close"], length=indicators_dict["COPPOCK"]["length"], fast=indicators_dict["COPPOCK"]["fast"],
+                                    slow=indicators_dict["COPPOCK"]["slow"])
+            dataframe["coppock"] = round(coppock_df, 2).fillna(0).values
+
+        if "ORB" in indicators_dict:
+            orb_up, orb_down = calculate_orb(dataframe=dataframe, start_time=indicators_dict["ORB"]["start_time"], end_time=indicators_dict["ORB"]["end_time"])
+            dataframe["orb_up"] = orb_up
+            dataframe["orb_down"] = orb_down
+
+        if "CHOPZONE" in indicators_dict:
+            cz_df = calculate_chop_zone(dataframe=dataframe, periods=indicators_dict["CHOPZONE"]["periods"])
+            dataframe["chop_zone_color"] = cz_df.iloc[:, 0]
+
+        if "SLOPE" in indicators_dict:
+            slope_df = calculate_slope(dataframe=dataframe, source=indicators_dict["SLOPE"]["source"])
+            dataframe[f'{indicators_dict["SLOPE"]["source"]}_slope'] = slope_df.iloc[:, 0]
+
         return dataframe
 
     except Exception as e:

{sysstra-0.1.2.2 → sysstra-0.1.2.4}/sysstra.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: sysstra
-Version: 0.1.2.2
+Version: 0.1.2.4
 Summary: Official Python Library for Sysstra Algo Trading
 Home-page: https://github.com/sysstra/sysstra
 Author: Anurag Singh Kushwah