pkscreener 0.46.20250810.756__cp312-cp312-win_amd64.whl → 0.46.20250908.764__cp312-cp312-win_amd64.whl

{pkscreener-0.46.20250810.756.data → pkscreener-0.46.20250908.764.data}/purelib/pkscreener/classes/MarketStatus.py

@@ -62,6 +62,7 @@ class MarketStatus(SingletonMixin, metaclass=SingletonType):
         self.attributes["marketStatus"] = status
 
     def getMarketStatus(self, progress=None, task_id=0, exchangeSymbol="^NSEI",namedOnly=False):
+        return "NA"
         lngStatus = ""
         try:
             # if not 'pytest' in sys.modules:
@@ -71,9 +72,9 @@ class MarketStatus(SingletonMixin, metaclass=SingletonType):
             with SuppressOutput(suppress_stdout=suppressLogs, suppress_stderr=suppressLogs):
                 if progress:
                     progress[task_id] = {"progress": 0, "total": 1}
-                _,lngStatus,_ = MarketStatus.nseFetcher.capitalMarketStatus(exchange=exchangeSymbol)
+                _,lngStatus,_ = "","TODO","" # MarketStatus.nseFetcher.capitalMarketStatus(exchange=exchangeSymbol)
                 if exchangeSymbol in ["^NSEI","^BSESN"] and not namedOnly:
-                    _,bseStatus,_ = MarketStatus.nseFetcher.capitalMarketStatus(exchange="^BSESN")
+                    _,bseStatus,_ = "","TODO","" #MarketStatus.nseFetcher.capitalMarketStatus(exchange="^BSESN")
                     lngStatus = f"{lngStatus} | {bseStatus}"
             if progress:
                 progress[task_id] = {"progress": 1, "total": 1}

{pkscreener-0.46.20250810.756.data → pkscreener-0.46.20250908.764.data}/purelib/pkscreener/classes/PKMarketOpenCloseAnalyser.py

@@ -288,9 +288,9 @@ class PKMarketOpenCloseAnalyser:
                 if df is not None and len(df) > 0:
                     close = PKMarketOpenCloseAnalyser.getMorningClose(df)
                     adjClose = df["Adj Close"][-1] if "Adj Close" in df.columns else close
-                    combinedCandle = {"Open":PKMarketOpenCloseAnalyser.getMorningOpen(df), "High":max(df["High"]), 
-                                    "Low":min(df["Low"]),"Close":close,
-                                    "Adj Close":adjClose,"Volume":sum(df["Volume"])}
+                    combinedCandle = {"open":PKMarketOpenCloseAnalyser.getMorningOpen(df), "high":max(df["high"]), 
+                                    "low":min(df["low"]),"close":close,
+                                    "Adj Close":adjClose,"volume":sum(df["volume"])}
                     tradingDate = df.index[-1] #PKDateUtilities.tradingDate()
                     timestamp = datetime.datetime.strptime(tradingDate.strftime("%Y-%m-%d %H:%M:%S"),"%Y-%m-%d %H:%M:%S")
                     df = pd.DataFrame([combinedCandle], columns=df.columns, index=[timestamp])
@@ -304,29 +304,29 @@ class PKMarketOpenCloseAnalyser:
 
     def getMorningOpen(df):
         try:
-            open = df["Open"][0]
+            open = df["open"][0]
         except KeyError: # pragma: no cover
-            open = df["Open"][df.index.values[0]]
+            open = df["open"][df.index.values[0]]
         index = 0
         while np.isnan(open) and index < len(df):
             try:
-                open = df["Open"][index + 1]
+                open = df["open"][index + 1]
             except KeyError: # pragma: no cover
-                open = df["Open"][df.index.values[index + 1]]
+                open = df["open"][df.index.values[index + 1]]
             index += 1
         return open
     
     def getMorningClose(df):
         try:
-            close = df["Close"][-1]
+            close = df["close"][-1]
         except KeyError: # pragma: no cover
-            close = df["Close"][df.index.values[-1]]
+            close = df["close"][df.index.values[-1]]
         index = len(df)
         while np.isnan(close) and index >= 0:
             try:
-                close = df["Close"][index - 1]
+                close = df["close"][index - 1]
             except KeyError: # pragma: no cover
-                close = df["Close"][df.index.values[index - 1]]
+                close = df["close"][df.index.values[index - 1]]
             index -= 1
         return close
     
@@ -459,15 +459,15 @@ class PKMarketOpenCloseAnalyser:
                 highTS, highRow = scrStats.findIntradayHighCrossover(df=df)
                 # buySell_df = scrStats.computeBuySellSignals(updatedCandleData[stock]["data"])
                 # OutputControls().printOutput(buySell_df)
-                dayHighLTP = dayHighLTP if pd.notna(dayHighLTP) else highRow["High"][-1]
+                dayHighLTP = dayHighLTP if pd.notna(dayHighLTP) else highRow["high"][-1]
                 sellTimestamps.append(PKDateUtilities.utc_to_ist(ts).strftime("%H:%M"))
                 dayHighTimestamps.append(PKDateUtilities.utc_to_ist(highTS).strftime("%H:%M"))
-                sellLTPs.append(row["High"][-1])
+                sellLTPs.append(row["high"][-1])
                 eodLTPs.append(round(endOfDayLTP,2))
                 dayHighLTPs.append(round(dayHighLTP,2))
                 eodDiffs.append(round(endOfDayLTP - morningLTP,2))
                 dayHighDiffs.append(round(dayHighLTP - morningLTP,2))
-                sqrOffDiffs.append(round(row["High"][-1] - morningLTP,2))
+                sqrOffDiffs.append(round(row["high"][-1] - morningLTP,2))
                 morningAlertLTPs.append(str(int(round(morningLTP,0))))
                 index += 1
             except: # pragma: no cover

{pkscreener-0.46.20250810.756.data → pkscreener-0.46.20250908.764.data}/purelib/pkscreener/classes/PKScanRunner.py

@@ -71,7 +71,7 @@ class PKScanRunner:
                 "52Wk-H",
                 "52Wk-L",
                 "%Chng",
-                "Volume",
+                "volume",
                 "MA-Signal",
                 "RSI",
                 "RSIi",
@@ -89,7 +89,7 @@ class PKScanRunner:
                 "52Wk-H",
                 "52Wk-L",
                 "%Chng",
-                "Volume",
+                "volume",
                 "MA-Signal",
                 "RSI",
                 "RSIi",

{pkscreener-0.46.20250810.756.data → pkscreener-0.46.20250908.764.data}/purelib/pkscreener/classes/Pktalib.py

@@ -49,26 +49,26 @@ if Imports["talib"]:
                 + colorText.END
             )
         try:
-            import pandas_ta as talib
+            import pandas_ta_classic as talib
             OutputControls().printOutput(
                 colorText.FAIL
-                + f"  [+] TA-Lib is not installed. Falling back on pandas_ta.\n  [+] For full coverage(candle patterns), you may wish to follow instructions from\n  [+] {taLink}"
+                + f"  [+] TA-Lib is not installed. Falling back on pandas_ta_classic.\n  [+] For full coverage(candle patterns), you may wish to follow instructions from\n  [+] {taLink}"
                 + colorText.END
             )
         except: # pragma: no cover
             OutputControls().printOutput(
                 colorText.FAIL
-                + f"  [+] pandas_ta is not installed. Falling back on pandas_ta also failed.\n  [+] For full coverage(candle patterns), you may wish to follow instructions from\n  [+] {taLink}"
+                + f"  [+] pandas_ta_classic is not installed. Falling back on pandas_ta_classic also failed.\n  [+] For full coverage(candle patterns), you may wish to follow instructions from\n  [+] {taLink}"
                 + colorText.END
             )
             pass
         pass
 else:
     try:
-        import pandas_ta as talib
+        import pandas_ta_classic as talib
         OutputControls().printOutput(
             colorText.FAIL
-            + "  [+] TA-Lib is not installed. Falling back on pandas_ta.\n  [+] For full coverage(candle patterns), you may wish to follow instructions from\n  [+] https://github.com/ta-lib/ta-lib-python"
+            + "  [+] TA-Lib is not installed. Falling back on pandas_ta_classic.\n  [+] For full coverage(candle patterns), you may wish to follow instructions from\n  [+] https://github.com/ta-lib/ta-lib-python"
             + colorText.END
         )
         sleep(3)
@@ -103,12 +103,12 @@ class pktalib:
         # identify potential areas of support and resistance more accurately 
         # and make better trading decisions.
         with pd.option_context('mode.chained_assignment', None):
-            df["VWAP_D"] = pktalib.VWAP(high=df["High"],low=df["Low"],close=df["Close"],volume=df["Volume"],anchor="D")
+            df["VWAP_D"] = pktalib.VWAP(high=df["high"],low=df["low"],close=df["close"],volume=df["volume"],anchor="D")
             # If we create a column 'typical_price', it should be identical with 'VWAP_D'
-            df['typical_price'] = (df['High'] + df['Low'] + df['Close'])/3
-            tpp_d = ((df['High'] + df['Low'] + df['Close'])*df['Volume'])/3
+            df['typical_price'] = (df["high"] + df["low"] + df["close"])/3
+            tpp_d = ((df["high"] + df["low"] + df["close"])*df["volume"])/3
             df['anchored_VWAP'] = tpp_d.where(df.index >= anchored_date).groupby(
-                df.index >= anchored_date).cumsum()/df['Volume'].where(
+                df.index >= anchored_date).cumsum()/df["volume"].where(
                     df.index >= anchored_date).groupby(
                         df.index >= anchored_date).cumsum()
         return df['anchored_VWAP']
@@ -132,7 +132,7 @@ class pktalib:
     @classmethod
     def VWAP(self, high, low, close, volume,anchor=None):
         try:
-            import pandas_ta as talib
+            import pandas_ta_classic as talib
             # Aligning the series
             # high,low,close = pktalib.align_series(high, low, close, fill_value=0)
             return talib.vwap(high, low, close, volume,anchor=anchor)
@@ -204,7 +204,7 @@ class pktalib:
     @classmethod
     def TriMA(self, close,length=10):
         try:
-            import pandas_ta as talib
+            import pandas_ta_classic as talib
             return talib.trima(close=close, length=length)
         except Exception:  # pragma: no cover
             # default_logger().debug(e, exc_info=True)
@@ -213,7 +213,7 @@ class pktalib:
     @classmethod
     def MACD(self, close, fast, slow, signal):
         try:
-            # import pandas_ta as talib
+            # import pandas_ta_classic as talib
             return talib.macd(close, fast, slow, signal, talib=Imports["talib"])
         except Exception:  # pragma: no cover
             # default_logger().debug(e, exc_info=True)
@@ -346,7 +346,7 @@ class pktalib:
     def ichimoku(
         self, df, tenkan=None, kijun=None, senkou=None, include_chikou=True, offset=None
     ):
-        import pandas_ta as ta
+        import pandas_ta_classic as ta
 
         ichimokudf, spandf = ta.ichimoku(
             df["high"], df["low"], df["close"], tenkan, kijun, senkou, False, 26
@@ -355,10 +355,10 @@ class pktalib:
 
     @classmethod
     def supertrend(self, df, length=7, multiplier=3):
-        import pandas_ta as ta
+        import pandas_ta_classic as ta
 
         sti = ta.supertrend(
-            df["High"], df["Low"], df["Close"], length=length, multiplier=multiplier
+            df["high"], df["low"], df["close"], length=length, multiplier=multiplier
         )
         # trend, direction, long, short
         # SUPERT_7_3.0  SUPERTd_7_3.0  SUPERTl_7_3.0  SUPERTs_7_3.0
@@ -373,17 +373,17 @@ class pktalib:
 
     # @classmethod
     # def momentum(self, df):
-    #     df.loc[:,'MOM'] = talib.MOM(df.loc[:,'Close'],2).apply(lambda x: round(x, 2))
+    #     df.loc[:,'MOM'] = talib.MOM(df.loc[:,"close"],2).apply(lambda x: round(x, 2))
     #     return df.loc[:,'MOM']
 
     # @classmethod
     # def get_dmi_df(self, df):
-    #     df.loc[:,'DMI'] = talib.DX(df.loc[:,'High'],df.loc[:,'Low'],df.loc[:,'Close'],timeperiod=14)
+    #     df.loc[:,'DMI'] = talib.DX(df.loc[:,"high"],df.loc[:,"low"],df.loc[:,"close"],timeperiod=14)
     #     return df.loc[:,'DMI']
 
     # @classmethod
     # def get_macd_df(self, df):
-    #     df.loc[:,'macd(12)'], df.loc[:,'macdsignal(9)'], df.loc[:,'macdhist(26)'] = talib.MACD(df.loc[:,'Close'], fastperiod=12, slowperiod=26, signalperiod=9)
+    #     df.loc[:,'macd(12)'], df.loc[:,'macdsignal(9)'], df.loc[:,'macdhist(26)'] = talib.MACD(df.loc[:,"close"], fastperiod=12, slowperiod=26, signalperiod=9)
     #     df.loc[:,'macd(12)'] = df.loc[:,'macd(12)'].apply(lambda x: round(x, 3))
     #     df.loc[:,'macdsignal(9)']= df.loc[:,'macdsignal(9)'].apply(lambda x: round(x, 3))
     #     df.loc[:,'macdhist(26)'] = df.loc[:,'macdhist(26)'].apply(lambda x: round(x, 3))
@@ -391,48 +391,48 @@ class pktalib:
 
     # @classmethod
     # def get_sma_df(self, df):
-    #     df.loc[:,'SMA(10)'] = talib.SMA(df.loc[:,'Close'],10).apply(lambda x: round(x, 2))
-    #     df.loc[:,'SMA(50)'] = talib.SMA(df.loc[:,'Close'],50).apply(lambda x: round(x, 2))
-    #     return df.loc[:,['Close','SMA(10)', 'SMA(50)']]
+    #     df.loc[:,'SMA(10)'] = talib.SMA(df.loc[:,"close"],10).apply(lambda x: round(x, 2))
+    #     df.loc[:,'SMA(50)'] = talib.SMA(df.loc[:,"close"],50).apply(lambda x: round(x, 2))
+    #     return df.loc[:,["close",'SMA(10)', 'SMA(50)']]
 
     # @classmethod
     # def get_ema_df(self, df):
-    #     df.loc[:,'EMA(9)'] = talib.EMA(df.loc[:,'Close'], timeperiod = 9).apply(lambda x: round(x, 2))
-    #     return df.loc[:,['Close','EMA(9)']]
+    #     df.loc[:,'EMA(9)'] = talib.EMA(df.loc[:,"close"], timeperiod = 9).apply(lambda x: round(x, 2))
+    #     return df.loc[:,["close",'EMA(9)']]
 
     # @classmethod
     # def get_adx_df(self, df):
-    #     df.loc[:,'ADX'] = talib.ADX(df.loc[:,'High'],df.loc[:,'Low'], df.loc[:,'Close'], timeperiod=14).apply(lambda x: round(x, 2))
+    #     df.loc[:,'ADX'] = talib.ADX(df.loc[:,"high"],df.loc[:,"low"], df.loc[:,"close"], timeperiod=14).apply(lambda x: round(x, 2))
     #     return df.loc[:,'ADX']
 
     # @classmethod
     # def get_bbands_df(self, df):
-    #     df.loc[:,'BBands-U'], df.loc[:,'BBands-M'], df.loc[:,'BBands-L'] = talib.BBANDS(df.loc[:,'Close'], timeperiod =20)
+    #     df.loc[:,'BBands-U'], df.loc[:,'BBands-M'], df.loc[:,'BBands-L'] = talib.BBANDS(df.loc[:,"close"], timeperiod =20)
     #     df.loc[:,'BBands-U'] = df.loc[:,'BBands-U'].apply(lambda x: round(x, 2))
     #     df.loc[:,'BBands-M'] = df.loc[:,'BBands-M'].apply(lambda x: round(x, 2))
     #     df.loc[:,'BBands-L'] = df.loc[:,'BBands-L'].apply(lambda x: round(x, 2))
-    #     return df[['Close','BBands-U','BBands-M','BBands-L']]
+    #     return df[["close",'BBands-U','BBands-M','BBands-L']]
 
     # @classmethod
     # def get_obv_df(self, df):
-    #     if ('Close' not in df.keys()) or ('Volume' not in df.keys()):
+    #     if ("close" not in df.keys()) or ("volume" not in df.keys()):
     #         return np.nan
-    #     df.loc[:,'OBV'] = talib.OBV(df.loc[:,'Close'], df.loc[:,'Volume'])
+    #     df.loc[:,'OBV'] = talib.OBV(df.loc[:,"close"], df.loc[:,"volume"])
     #     return df.loc[:,'OBV']
 
     # @classmethod
     # def get_atr_df(self, df):
-    #     df.loc[:,'ATR'] = talib.ATR(df.loc[:,'High'], df.loc[:,'Low'], df.loc[:,'Close'], timeperiod=14).apply(lambda x: round(x, 2))
+    #     df.loc[:,'ATR'] = talib.ATR(df.loc[:,"high"], df.loc[:,"low"], df.loc[:,"close"], timeperiod=14).apply(lambda x: round(x, 2))
     #     return df.loc[:,'ATR']
 
     # @classmethod
     # def get_natr_df(self, df):
-    #     df.loc[:,'NATR'] = talib.NATR(df.loc[:,'High'], df.loc[:,'Low'], df.loc[:,'Close'], timeperiod=14).apply(lambda x: round(x, 2))
+    #     df.loc[:,'NATR'] = talib.NATR(df.loc[:,"high"], df.loc[:,"low"], df.loc[:,"close"], timeperiod=14).apply(lambda x: round(x, 2))
     #     return df.loc[:,'NATR']
 
     # @classmethod
     # def get_trange_df(self, df):
-    #     df.loc[:,'TRANGE'] = talib.TRANGE(df.loc[:,'High'], df.loc[:,'Low'], df.loc[:,'Close']).apply(lambda x: round(x, 2))
+    #     df.loc[:,'TRANGE'] = talib.TRANGE(df.loc[:,"high"], df.loc[:,"low"], df.loc[:,"close"]).apply(lambda x: round(x, 2))
     #     return df.loc[:,'TRANGE']
 
     # @classmethod
@@ -443,9 +443,9 @@ class pktalib:
 
     #     @return: fasts, slows
     #     """
-    #     highs = df.loc[:,'High']
-    #     lows = df.loc[:,'Low']
-    #     closes = df.loc[:,'Close']
+    #     highs = df.loc[:,"high"]
+    #     lows = df.loc[:,"low"]
+    #     closes = df.loc[:,"close"]
     #     slowPeriod=30
     #     fastPeriod=3
     #     atr = self.get_atr_df(df)
@@ -467,7 +467,7 @@ class pktalib:
     #     """
     #     ATR(14)/MA(14)
     #     """
-    #     closes = df.loc[:,'Close']
+    #     closes = df.loc[:,"close"]
 
     #     atr = self.get_atr_df(df)
     #     ma = talib.MA(closes, timeperiod=14)
@@ -501,7 +501,7 @@ class pktalib:
                     result = pd.Series(high + 2 * (PP - low))
                 elif pivotPoint == "S3":
                     result = pd.Series(low - 2 * (high - PP))
-            psr = {'Close':close, 'PP':round(PP,2)}
+            psr = {"close":close, 'PP':round(PP,2)}
             if pivotPoint != "PP" and result is not None:
                 psr[pivotPoint] = round(result,2)
             with pd.option_context('mode.chained_assignment', None):

{pkscreener-0.46.20250810.756.data → pkscreener-0.46.20250908.764.data}/purelib/pkscreener/classes/PortfolioXRay.py

@@ -399,7 +399,7 @@ def statScanCalculationForPatterns(*args, **kwargs):
     return scanResults
 
 def ensureColumnsExist(saveResults):
-    columns = ['Stock', 'Date', 'Volume', 'Trend', 'MA-Signal', 'LTP', '52Wk-H',
+    columns = ['Stock', 'Date', "volume", 'Trend', 'MA-Signal', 'LTP', '52Wk-H',
                '52Wk-L', '1-Pd', '2-Pd', '3-Pd', '4-Pd', '5-Pd', '10-Pd', '15-Pd',
                '22-Pd', '30-Pd', 'Consol.', 'Breakout', 'RSI', 'Pattern', 'CCI',
                'LTP1', 'Growth1', 'LTP2', 'Growth2', 'LTP3', 'Growth3', 'LTP4',
@@ -423,7 +423,7 @@ def cleanupData(savedResults):
 
     saveResults["LTP"] = saveResults["LTP"].astype(float).fillna(0.0)
     saveResults["RSI"] = saveResults["RSI"].astype(float).fillna(0.0)
-    saveResults.loc[:, "Volume"] = saveResults.loc[:, "Volume"].apply(
+    saveResults.loc[:, "volume"] = saveResults.loc[:, "volume"].apply(
             lambda x: x.replace("x", "")
         )
     if f"Trend({configManager.daysToLookback}Prds)" not in saveResults.columns:
@@ -455,7 +455,7 @@ def cleanupData(savedResults):
             ].apply(lambda x: x.replace("(Potential)", "") if x is not None else x)
         saveResults["Breakout"] = saveResults["Breakout"].astype(float).fillna(0.0)
         saveResults["Resistance"] = saveResults["Resistance"].astype(float).fillna(0.0)
-    saveResults["Volume"] = saveResults["Volume"].astype(float).fillna(0.0)
+    saveResults["volume"] = saveResults["volume"].astype(float).fillna(0.0)
     saveResults[f"Consol."] = (
             saveResults[f"Consol."].astype(float).fillna(0.0)
         )
@@ -1036,13 +1036,13 @@ def filterMASignalResist(df):
 def filterVolumeLessThan25(df):
     if df is None:
         return None
-    return df[df["Volume"] < 2.5].fillna(0.0)
+    return df[df["volume"] < 2.5].fillna(0.0)
 
 
 def filterVolumeMoreThan25(df):
     if df is None:
         return None
-    return df[df["Volume"] >= 2.5].fillna(0.0)
+    return df[df["volume"] >= 2.5].fillna(0.0)
 
 
 def filterConsolidating10Percent(df):