Make codebase compatible with pandas 2.0+

Co-authored-by: xgboosted <1528712+xgboosted@users.noreply.github.com>

pandas_ta_classic/candles/cdl_doji.py

@@ -38,7 +38,15 @@ def cdl_doji(open_, high, low, close, length=None, factor=None, scalar=None, asi
     if "fillna" in kwargs:
         doji.fillna(kwargs["fillna"], inplace=True)
     if "fill_method" in kwargs:
-        doji.fillna(method=kwargs["fill_method"], inplace=True)
+        if "fill_method" in kwargs:
+
+            if kwargs["fill_method"] == "ffill":
+
+                doji.ffill(inplace=True)
+
+            elif kwargs["fill_method"] == "bfill":
+
+                doji.bfill(inplace=True)
 
     # Name and Categorize it
     doji.name = f"CDL_DOJI_{length}_{0.01 * factor}"

pandas_ta_classic/candles/cdl_inside.py

@@ -26,7 +26,15 @@ def cdl_inside(open_, high, low, close, asbool=False, offset=None, **kwargs):
     if "fillna" in kwargs:
         inside.fillna(kwargs["fillna"], inplace=True)
     if "fill_method" in kwargs:
-        inside.fillna(method=kwargs["fill_method"], inplace=True)
+        if "fill_method" in kwargs:
+
+            if kwargs["fill_method"] == "ffill":
+
+                inside.ffill(inplace=True)
+
+            elif kwargs["fill_method"] == "bfill":
+
+                inside.bfill(inplace=True)
 
     # Name and Categorize it
     inside.name = f"CDL_INSIDE"

pandas_ta_classic/candles/cdl_pattern.py

@@ -72,7 +72,15 @@ def cdl_pattern(open_, high, low, close, name: Union[str, Sequence[str]]="all",
             if "fillna" in kwargs:
                 pattern_result.fillna(kwargs["fillna"], inplace=True)
             if "fill_method" in kwargs:
-                pattern_result.fillna(method=kwargs["fill_method"], inplace=True)
+                if "fill_method" in kwargs:
+
+                    if kwargs["fill_method"] == "ffill":
+
+                        pattern_result.ffill(inplace=True)
+
+                    elif kwargs["fill_method"] == "bfill":
+
+                        pattern_result.bfill(inplace=True)
 
             result[f"CDL_{n.upper()}"] = pattern_result
 

pandas_ta_classic/candles/cdl_z.py

@@ -47,7 +47,15 @@ def cdl_z(open_, high, low, close, length=None, full=None, ddof=None, offset=Non
     if "fillna" in kwargs:
         df.fillna(kwargs["fillna"], inplace=True)
     if "fill_method" in kwargs:
-        df.fillna(method=kwargs["fill_method"], inplace=True)
+        if "fill_method" in kwargs:
+
+            if kwargs["fill_method"] == "ffill":
+
+                df.ffill(inplace=True)
+
+            elif kwargs["fill_method"] == "bfill":
+
+                df.bfill(inplace=True)
 
     # Name and Categorize it
     df.name = f"CDL_Z{_props}"

pandas_ta_classic/candles/ha.py

@@ -35,7 +35,15 @@ def ha(open_, high, low, close, offset=None, **kwargs):
     if "fillna" in kwargs:
         df.fillna(kwargs["fillna"], inplace=True)
     if "fill_method" in kwargs:
-        df.fillna(method=kwargs["fill_method"], inplace=True)
+        if "fill_method" in kwargs:
+
+            if kwargs["fill_method"] == "ffill":
+
+                df.ffill(inplace=True)
+
+            elif kwargs["fill_method"] == "bfill":
+
+                df.bfill(inplace=True)
 
     # Name and Categorize it
     df.name = "Heikin-Ashi"

pandas_ta_classic/cycles/ebsw.py

@@ -68,7 +68,15 @@ def ebsw(close, length=None, bars=None, offset=None, **kwargs):
     if "fillna" in kwargs:
         ebsw.fillna(kwargs["fillna"], inplace=True)
     if "fill_method" in kwargs:
-        ebsw.fillna(method=kwargs["fill_method"], inplace=True)
+        if "fill_method" in kwargs:
+
+            if kwargs["fill_method"] == "ffill":
+
+                ebsw.ffill(inplace=True)
+
+            elif kwargs["fill_method"] == "bfill":
+
+                ebsw.bfill(inplace=True)
 
     # Name and Categorize it
     ebsw.name = f"EBSW_{length}_{bars}"

pandas_ta_classic/momentum/ao.py

@@ -31,7 +31,15 @@ def ao(high, low, fast=None, slow=None, offset=None, **kwargs):
     if "fillna" in kwargs:
         ao.fillna(kwargs["fillna"], inplace=True)
     if "fill_method" in kwargs:
-        ao.fillna(method=kwargs["fill_method"], inplace=True)
+        if "fill_method" in kwargs:
+
+            if kwargs["fill_method"] == "ffill":
+
+                ao.ffill(inplace=True)
+
+            elif kwargs["fill_method"] == "bfill":
+
+                ao.bfill(inplace=True)
 
     # Name and Categorize it
     ao.name = f"AO_{fast}_{slow}"

pandas_ta_classic/momentum/apo.py

@@ -35,7 +35,15 @@ def apo(close, fast=None, slow=None, mamode=None, talib=None, offset=None, **kwa
     if "fillna" in kwargs:
         apo.fillna(kwargs["fillna"], inplace=True)
     if "fill_method" in kwargs:
-        apo.fillna(method=kwargs["fill_method"], inplace=True)
+        if "fill_method" in kwargs:
+
+            if kwargs["fill_method"] == "ffill":
+
+                apo.ffill(inplace=True)
+
+            elif kwargs["fill_method"] == "bfill":
+
+                apo.bfill(inplace=True)
 
     # Name and Categorize it
     apo.name = f"APO_{fast}_{slow}"

pandas_ta_classic/momentum/bias.py

@@ -25,7 +25,15 @@ def bias(close, length=None, mamode=None, offset=None, **kwargs):
     if "fillna" in kwargs:
         bias.fillna(kwargs["fillna"], inplace=True)
     if "fill_method" in kwargs:
-        bias.fillna(method=kwargs["fill_method"], inplace=True)
+        if "fill_method" in kwargs:
+
+            if kwargs["fill_method"] == "ffill":
+
+                bias.ffill(inplace=True)
+
+            elif kwargs["fill_method"] == "bfill":
+
+                bias.bfill(inplace=True)
 
     # Name and Categorize it
     bias.name = f"BIAS_{bma.name}"

pandas_ta_classic/momentum/bop.py

@@ -31,7 +31,15 @@ def bop(open_, high, low, close, scalar=None, talib=None, offset=None, **kwargs)
     if "fillna" in kwargs:
         bop.fillna(kwargs["fillna"], inplace=True)
     if "fill_method" in kwargs:
-        bop.fillna(method=kwargs["fill_method"], inplace=True)
+        if "fill_method" in kwargs:
+
+            if kwargs["fill_method"] == "ffill":
+
+                bop.ffill(inplace=True)
+
+            elif kwargs["fill_method"] == "bfill":
+
+                bop.bfill(inplace=True)
 
     # Name and Categorize it
     bop.name = f"BOP"

pandas_ta_classic/momentum/brar.py

@@ -42,8 +42,24 @@ def brar(open_, high, low, close, length=None, scalar=None, drift=None, offset=N
         ar.fillna(kwargs["fillna"], inplace=True)
         br.fillna(kwargs["fillna"], inplace=True)
     if "fill_method" in kwargs:
-        ar.fillna(method=kwargs["fill_method"], inplace=True)
-        br.fillna(method=kwargs["fill_method"], inplace=True)
+        if "fill_method" in kwargs:
+
+            if kwargs["fill_method"] == "ffill":
+
+                ar.ffill(inplace=True)
+
+            elif kwargs["fill_method"] == "bfill":
+
+                ar.bfill(inplace=True)
+        if "fill_method" in kwargs:
+
+            if kwargs["fill_method"] == "ffill":
+
+                br.ffill(inplace=True)
+
+            elif kwargs["fill_method"] == "bfill":
+
+                br.bfill(inplace=True)
 
     # Name and Categorize it
     _props = f"_{length}"

pandas_ta_classic/momentum/cci.py

@@ -38,7 +38,15 @@ def cci(high, low, close, length=None, c=None, talib=None, offset=None, **kwargs
     if "fillna" in kwargs:
         cci.fillna(kwargs["fillna"], inplace=True)
     if "fill_method" in kwargs:
-        cci.fillna(method=kwargs["fill_method"], inplace=True)
+        if "fill_method" in kwargs:
+
+            if kwargs["fill_method"] == "ffill":
+
+                cci.ffill(inplace=True)
+
+            elif kwargs["fill_method"] == "bfill":
+
+                cci.bfill(inplace=True)
 
     # Name and Categorize it
     cci.name = f"CCI_{length}_{c}"

pandas_ta_classic/momentum/cfo.py

@@ -26,7 +26,15 @@ def cfo(close, length=None, scalar=None, drift=None, offset=None, **kwargs):
     if "fillna" in kwargs:
         cfo.fillna(kwargs["fillna"], inplace=True)
     if "fill_method" in kwargs:
-        cfo.fillna(method=kwargs["fill_method"], inplace=True)
+        if "fill_method" in kwargs:
+
+            if kwargs["fill_method"] == "ffill":
+
+                cfo.ffill(inplace=True)
+
+            elif kwargs["fill_method"] == "bfill":
+
+                cfo.bfill(inplace=True)
 
     # Name and Categorize it
     cfo.name = f"CFO_{length}"

pandas_ta_classic/momentum/cg.py

@@ -24,7 +24,15 @@ def cg(close, length=None, offset=None, **kwargs):
     if "fillna" in kwargs:
         cg.fillna(kwargs["fillna"], inplace=True)
     if "fill_method" in kwargs:
-        cg.fillna(method=kwargs["fill_method"], inplace=True)
+        if "fill_method" in kwargs:
+
+            if kwargs["fill_method"] == "ffill":
+
+                cg.ffill(inplace=True)
+
+            elif kwargs["fill_method"] == "bfill":
+
+                cg.bfill(inplace=True)
 
     # Name and Categorize it
     cg.name = f"CG_{length}"

pandas_ta_classic/momentum/cmo.py

@@ -42,7 +42,15 @@ def cmo(close, length=None, scalar=None, talib=None, drift=None, offset=None, **
     if "fillna" in kwargs:
         cmo.fillna(kwargs["fillna"], inplace=True)
     if "fill_method" in kwargs:
-        cmo.fillna(method=kwargs["fill_method"], inplace=True)
+        if "fill_method" in kwargs:
+
+            if kwargs["fill_method"] == "ffill":
+
+                cmo.ffill(inplace=True)
+
+            elif kwargs["fill_method"] == "bfill":
+
+                cmo.bfill(inplace=True)
 
     # Name and Categorize it
     cmo.name = f"CMO_{length}"

pandas_ta_classic/momentum/coppock.py

@@ -27,7 +27,15 @@ def coppock(close, length=None, fast=None, slow=None, offset=None, **kwargs):
     if "fillna" in kwargs:
         coppock.fillna(kwargs["fillna"], inplace=True)
     if "fill_method" in kwargs:
-        coppock.fillna(method=kwargs["fill_method"], inplace=True)
+        if "fill_method" in kwargs:
+
+            if kwargs["fill_method"] == "ffill":
+
+                coppock.ffill(inplace=True)
+
+            elif kwargs["fill_method"] == "bfill":
+
+                coppock.bfill(inplace=True)
 
     # Name and Categorize it
     coppock.name = f"COPC_{fast}_{slow}_{length}"

pandas_ta_classic/momentum/cti.py

@@ -22,7 +22,15 @@ def cti(close, length=None, offset=None, **kwargs) -> Series:
     if "fillna" in kwargs:
         cti.fillna(method=kwargs["fillna"], inplace=True)
     if "fill_method" in kwargs:
-        cti.fillna(method=kwargs["fill_method"], inplace=True)
+        if "fill_method" in kwargs:
+
+            if kwargs["fill_method"] == "ffill":
+
+                cti.ffill(inplace=True)
+
+            elif kwargs["fill_method"] == "bfill":
+
+                cti.bfill(inplace=True)
 
     cti.name = f"CTI_{length}"
     cti.category = "momentum"

pandas_ta_classic/momentum/er.py

@@ -28,7 +28,15 @@ def er(close, length=None, drift=None, offset=None, **kwargs):
     if "fillna" in kwargs:
         er.fillna(kwargs["fillna"], inplace=True)
     if "fill_method" in kwargs:
-        er.fillna(method=kwargs["fill_method"], inplace=True)
+        if "fill_method" in kwargs:
+
+            if kwargs["fill_method"] == "ffill":
+
+                er.ffill(inplace=True)
+
+            elif kwargs["fill_method"] == "bfill":
+
+                er.bfill(inplace=True)
 
     # Name and Categorize it
     er.name = f"ER_{length}"

pandas_ta_classic/momentum/eri.py

@@ -30,8 +30,24 @@ def eri(high, low, close, length=None, offset=None, **kwargs):
         bull.fillna(kwargs["fillna"], inplace=True)
         bear.fillna(kwargs["fillna"], inplace=True)
     if "fill_method" in kwargs:
-        bull.fillna(method=kwargs["fill_method"], inplace=True)
-        bear.fillna(method=kwargs["fill_method"], inplace=True)
+        if "fill_method" in kwargs:
+
+            if kwargs["fill_method"] == "ffill":
+
+                bull.ffill(inplace=True)
+
+            elif kwargs["fill_method"] == "bfill":
+
+                bull.bfill(inplace=True)
+        if "fill_method" in kwargs:
+
+            if kwargs["fill_method"] == "ffill":
+
+                bear.ffill(inplace=True)
+
+            elif kwargs["fill_method"] == "bfill":
+
+                bear.bfill(inplace=True)
 
     # Name and Categorize it
     bull.name = f"BULLP_{length}"

pandas_ta_classic/momentum/fisher.py

@@ -49,8 +49,24 @@ def fisher(high, low, length=None, signal=None, offset=None, **kwargs):
         fisher.fillna(kwargs["fillna"], inplace=True)
         signalma.fillna(kwargs["fillna"], inplace=True)
     if "fill_method" in kwargs:
-        fisher.fillna(method=kwargs["fill_method"], inplace=True)
-        signalma.fillna(method=kwargs["fill_method"], inplace=True)
+        if "fill_method" in kwargs:
+
+            if kwargs["fill_method"] == "ffill":
+
+                fisher.ffill(inplace=True)
+
+            elif kwargs["fill_method"] == "bfill":
+
+                fisher.bfill(inplace=True)
+        if "fill_method" in kwargs:
+
+            if kwargs["fill_method"] == "ffill":
+
+                signalma.ffill(inplace=True)
+
+            elif kwargs["fill_method"] == "bfill":
+
+                signalma.bfill(inplace=True)
 
     # Name and Categorize it
     _props = f"_{length}_{signal}"

pandas_ta_classic/momentum/inertia.py

@@ -43,7 +43,15 @@ def inertia(close=None, high=None, low=None, length=None, rvi_length=None, scala
     if "fillna" in kwargs:
         inertia.fillna(kwargs["fillna"], inplace=True)
     if "fill_method" in kwargs:
-        inertia.fillna(method=kwargs["fill_method"], inplace=True)
+        if "fill_method" in kwargs:
+
+            if kwargs["fill_method"] == "ffill":
+
+                inertia.ffill(inplace=True)
+
+            elif kwargs["fill_method"] == "bfill":
+
+                inertia.bfill(inplace=True)
 
     # Name & Category
     _props = f"_{length}_{rvi_length}"

pandas_ta_classic/momentum/kdj.py

@@ -39,9 +39,33 @@ def kdj(high=None, low=None, close=None, length=None, signal=None, offset=None,
         d.fillna(kwargs["fillna"], inplace=True)
         j.fillna(kwargs["fillna"], inplace=True)
     if "fill_method" in kwargs:
-        k.fillna(method=kwargs["fill_method"], inplace=True)
-        d.fillna(method=kwargs["fill_method"], inplace=True)
-        j.fillna(method=kwargs["fill_method"], inplace=True)
+        if "fill_method" in kwargs:
+
+            if kwargs["fill_method"] == "ffill":
+
+                k.ffill(inplace=True)
+
+            elif kwargs["fill_method"] == "bfill":
+
+                k.bfill(inplace=True)
+        if "fill_method" in kwargs:
+
+            if kwargs["fill_method"] == "ffill":
+
+                d.ffill(inplace=True)
+
+            elif kwargs["fill_method"] == "bfill":
+
+                d.bfill(inplace=True)
+        if "fill_method" in kwargs:
+
+            if kwargs["fill_method"] == "ffill":
+
+                j.ffill(inplace=True)
+
+            elif kwargs["fill_method"] == "bfill":
+
+                j.bfill(inplace=True)
 
     # Name and Categorize it
     _params = f"_{length}_{signal}"

pandas_ta_classic/momentum/kst.py

@@ -44,8 +44,24 @@ def kst(close, roc1=None, roc2=None, roc3=None, roc4=None, sma1=None, sma2=None,
         kst.fillna(kwargs["fillna"], inplace=True)
         kst_signal.fillna(kwargs["fillna"], inplace=True)
     if "fill_method" in kwargs:
-        kst.fillna(method=kwargs["fill_method"], inplace=True)
-        kst_signal.fillna(method=kwargs["fill_method"], inplace=True)
+        if "fill_method" in kwargs:
+
+            if kwargs["fill_method"] == "ffill":
+
+                kst.ffill(inplace=True)
+
+            elif kwargs["fill_method"] == "bfill":
+
+                kst.bfill(inplace=True)
+        if "fill_method" in kwargs:
+
+            if kwargs["fill_method"] == "ffill":
+
+                kst_signal.ffill(inplace=True)
+
+            elif kwargs["fill_method"] == "bfill":
+
+                kst_signal.bfill(inplace=True)
 
     # Name and Categorize it
     kst.name = f"KST_{roc1}_{roc2}_{roc3}_{roc4}_{sma1}_{sma2}_{sma3}_{sma4}"

pandas_ta_classic/momentum/macd.py

@@ -50,9 +50,33 @@ def macd(close, fast=None, slow=None, signal=None, talib=None, offset=None, **kw
         histogram.fillna(kwargs["fillna"], inplace=True)
         signalma.fillna(kwargs["fillna"], inplace=True)
     if "fill_method" in kwargs:
-        macd.fillna(method=kwargs["fill_method"], inplace=True)
-        histogram.fillna(method=kwargs["fill_method"], inplace=True)
-        signalma.fillna(method=kwargs["fill_method"], inplace=True)
+        if "fill_method" in kwargs:
+
+            if kwargs["fill_method"] == "ffill":
+
+                macd.ffill(inplace=True)
+
+            elif kwargs["fill_method"] == "bfill":
+
+                macd.bfill(inplace=True)
+        if "fill_method" in kwargs:
+
+            if kwargs["fill_method"] == "ffill":
+
+                histogram.ffill(inplace=True)
+
+            elif kwargs["fill_method"] == "bfill":
+
+                histogram.bfill(inplace=True)
+        if "fill_method" in kwargs:
+
+            if kwargs["fill_method"] == "ffill":
+
+                signalma.ffill(inplace=True)
+
+            elif kwargs["fill_method"] == "bfill":
+
+                signalma.bfill(inplace=True)
 
     # Name and Categorize it
     _asmode = "AS" if as_mode else ""

pandas_ta_classic/momentum/mom.py

@@ -28,7 +28,15 @@ def mom(close, length=None, talib=None, offset=None, **kwargs):
     if "fillna" in kwargs:
         mom.fillna(kwargs["fillna"], inplace=True)
     if "fill_method" in kwargs:
-        mom.fillna(method=kwargs["fill_method"], inplace=True)
+        if "fill_method" in kwargs:
+
+            if kwargs["fill_method"] == "ffill":
+
+                mom.ffill(inplace=True)
+
+            elif kwargs["fill_method"] == "bfill":
+
+                mom.bfill(inplace=True)
 
     # Name and Categorize it
     mom.name = f"MOM_{length}"

pandas_ta_classic/momentum/pgo.py

@@ -27,7 +27,15 @@ def pgo(high, low, close, length=None, offset=None, **kwargs):
     if "fillna" in kwargs:
         pgo.fillna(kwargs["fillna"], inplace=True)
     if "fill_method" in kwargs:
-        pgo.fillna(method=kwargs["fill_method"], inplace=True)
+        if "fill_method" in kwargs:
+
+            if kwargs["fill_method"] == "ffill":
+
+                pgo.ffill(inplace=True)
+
+            elif kwargs["fill_method"] == "bfill":
+
+                pgo.bfill(inplace=True)
 
     # Name and Categorize it
     pgo.name = f"PGO_{length}"

pandas_ta_classic/momentum/ppo.py

@@ -46,9 +46,33 @@ def ppo(close, fast=None, slow=None, signal=None, scalar=None, mamode=None, tali
         histogram.fillna(kwargs["fillna"], inplace=True)
         signalma.fillna(kwargs["fillna"], inplace=True)
     if "fill_method" in kwargs:
-        ppo.fillna(method=kwargs["fill_method"], inplace=True)
-        histogram.fillna(method=kwargs["fill_method"], inplace=True)
-        signalma.fillna(method=kwargs["fill_method"], inplace=True)
+        if "fill_method" in kwargs:
+
+            if kwargs["fill_method"] == "ffill":
+
+                ppo.ffill(inplace=True)
+
+            elif kwargs["fill_method"] == "bfill":
+
+                ppo.bfill(inplace=True)
+        if "fill_method" in kwargs:
+
+            if kwargs["fill_method"] == "ffill":
+
+                histogram.ffill(inplace=True)
+
+            elif kwargs["fill_method"] == "bfill":
+
+                histogram.bfill(inplace=True)
+        if "fill_method" in kwargs:
+
+            if kwargs["fill_method"] == "ffill":
+
+                signalma.ffill(inplace=True)
+
+            elif kwargs["fill_method"] == "bfill":
+
+                signalma.bfill(inplace=True)
 
     # Name and Categorize it
     _props = f"_{fast}_{slow}_{signal}"

pandas_ta_classic/momentum/psl.py

@@ -35,7 +35,15 @@ def psl(close, open_=None, length=None, scalar=None, drift=None, offset=None, **
     if "fillna" in kwargs:
         psl.fillna(kwargs["fillna"], inplace=True)
     if "fill_method" in kwargs:
-        psl.fillna(method=kwargs["fill_method"], inplace=True)
+        if "fill_method" in kwargs:
+
+            if kwargs["fill_method"] == "ffill":
+
+                psl.ffill(inplace=True)
+
+            elif kwargs["fill_method"] == "bfill":
+
+                psl.bfill(inplace=True)
 
     # Name and Categorize it
     _props = f"_{length}"

pandas_ta_classic/momentum/pvo.py

@@ -39,9 +39,33 @@ def pvo(volume, fast=None, slow=None, signal=None, scalar=None, offset=None, **k
         histogram.fillna(kwargs["fillna"], inplace=True)
         signalma.fillna(kwargs["fillna"], inplace=True)
     if "fill_method" in kwargs:
-        pvo.fillna(method=kwargs["fill_method"], inplace=True)
-        histogram.fillna(method=kwargs["fill_method"], inplace=True)
-        signalma.fillna(method=kwargs["fill_method"], inplace=True)
+        if "fill_method" in kwargs:
+
+            if kwargs["fill_method"] == "ffill":
+
+                pvo.ffill(inplace=True)
+
+            elif kwargs["fill_method"] == "bfill":
+
+                pvo.bfill(inplace=True)
+        if "fill_method" in kwargs:
+
+            if kwargs["fill_method"] == "ffill":
+
+                histogram.ffill(inplace=True)
+
+            elif kwargs["fill_method"] == "bfill":
+
+                histogram.bfill(inplace=True)
+        if "fill_method" in kwargs:
+
+            if kwargs["fill_method"] == "ffill":
+
+                signalma.ffill(inplace=True)
+
+            elif kwargs["fill_method"] == "bfill":
+
+                signalma.bfill(inplace=True)
 
     # Name and Categorize it
     _props = f"_{fast}_{slow}_{signal}"

pandas_ta_classic/momentum/qqe.py

@@ -95,10 +95,42 @@ def qqe(close, length=None, smooth=None, factor=None, mamode=None, drift=None, o
         qqe_long.fillna(kwargs["fillna"], inplace=True)
         qqe_short.fillna(kwargs["fillna"], inplace=True)
     if "fill_method" in kwargs:
-        rsi_ma.fillna(method=kwargs["fill_method"], inplace=True)
-        qqe.fillna(method=kwargs["fill_method"], inplace=True)
-        qqe_long.fillna(method=kwargs["fill_method"], inplace=True)
-        qqe_short.fillna(method=kwargs["fill_method"], inplace=True)
+        if "fill_method" in kwargs:
+
+            if kwargs["fill_method"] == "ffill":
+
+                rsi_ma.ffill(inplace=True)
+
+            elif kwargs["fill_method"] == "bfill":
+
+                rsi_ma.bfill(inplace=True)
+        if "fill_method" in kwargs:
+
+            if kwargs["fill_method"] == "ffill":
+
+                qqe.ffill(inplace=True)
+
+            elif kwargs["fill_method"] == "bfill":
+
+                qqe.bfill(inplace=True)
+        if "fill_method" in kwargs:
+
+            if kwargs["fill_method"] == "ffill":
+
+                qqe_long.ffill(inplace=True)
+
+            elif kwargs["fill_method"] == "bfill":
+
+                qqe_long.bfill(inplace=True)
+        if "fill_method" in kwargs:
+
+            if kwargs["fill_method"] == "ffill":
+
+                qqe_short.ffill(inplace=True)
+
+            elif kwargs["fill_method"] == "bfill":
+
+                qqe_short.bfill(inplace=True)
 
     # Name and Categorize it
     _props = f"{_mode}_{length}_{smooth}_{factor}"

pandas_ta_classic/momentum/roc.py

@@ -30,7 +30,15 @@ def roc(close, length=None, scalar=None, talib=None, offset=None, **kwargs):
     if "fillna" in kwargs:
         roc.fillna(kwargs["fillna"], inplace=True)
     if "fill_method" in kwargs:
-        roc.fillna(method=kwargs["fill_method"], inplace=True)
+        if "fill_method" in kwargs:
+
+            if kwargs["fill_method"] == "ffill":
+
+                roc.ffill(inplace=True)
+
+            elif kwargs["fill_method"] == "bfill":
+
+                roc.bfill(inplace=True)
 
     # Name and Categorize it
     roc.name = f"ROC_{length}"

pandas_ta_classic/momentum/rsi.py

@@ -41,7 +41,15 @@ def rsi(close, length=None, scalar=None, talib=None, drift=None, offset=None, **
     if "fillna" in kwargs:
         rsi.fillna(kwargs["fillna"], inplace=True)
     if "fill_method" in kwargs:
-        rsi.fillna(method=kwargs["fill_method"], inplace=True)
+        if "fill_method" in kwargs:
+
+            if kwargs["fill_method"] == "ffill":
+
+                rsi.ffill(inplace=True)
+
+            elif kwargs["fill_method"] == "bfill":
+
+                rsi.bfill(inplace=True)
 
     # Name and Categorize it
     rsi.name = f"RSI_{length}"

pandas_ta_classic/momentum/rsx.py

@@ -87,7 +87,15 @@ def rsx(close, length=None, drift=None, offset=None, **kwargs):
     if "fillna" in kwargs:
         rsx.fillna(kwargs["fillna"], inplace=True)
     if "fill_method" in kwargs:
-        rsx.fillna(method=kwargs["fill_method"], inplace=True)
+        if "fill_method" in kwargs:
+
+            if kwargs["fill_method"] == "ffill":
+
+                rsx.ffill(inplace=True)
+
+            elif kwargs["fill_method"] == "bfill":
+
+                rsx.bfill(inplace=True)
 
     # Name and Categorize it
     rsx.name = f"RSX_{length}"

pandas_ta_classic/momentum/rvgi.py

@@ -37,8 +37,24 @@ def rvgi(open_, high, low, close, length=None, swma_length=None, offset=None, **
         rvgi.fillna(kwargs["fillna"], inplace=True)
         signal.fillna(kwargs["fillna"], inplace=True)
     if "fill_method" in kwargs:
-        rvgi.fillna(method=kwargs["fill_method"], inplace=True)
-        signal.fillna(method=kwargs["fill_method"], inplace=True)
+        if "fill_method" in kwargs:
+
+            if kwargs["fill_method"] == "ffill":
+
+                rvgi.ffill(inplace=True)
+
+            elif kwargs["fill_method"] == "bfill":
+
+                rvgi.bfill(inplace=True)
+        if "fill_method" in kwargs:
+
+            if kwargs["fill_method"] == "ffill":
+
+                signal.ffill(inplace=True)
+
+            elif kwargs["fill_method"] == "bfill":
+
+                signal.bfill(inplace=True)
 
     # Name & Category
     rvgi.name = f"RVGI_{length}_{swma_length}"

pandas_ta_classic/momentum/slope.py

@@ -30,7 +30,15 @@ def slope( close, length=None, as_angle=None, to_degrees=None, vertical=None, of
     if "fillna" in kwargs:
         slope.fillna(kwargs["fillna"], inplace=True)
     if "fill_method" in kwargs:
-        slope.fillna(method=kwargs["fill_method"], inplace=True)
+        if "fill_method" in kwargs:
+
+            if kwargs["fill_method"] == "ffill":
+
+                slope.ffill(inplace=True)
+
+            elif kwargs["fill_method"] == "bfill":
+
+                slope.bfill(inplace=True)
 
     # Name and Categorize it
     slope.name = f"SLOPE_{length}" if not as_angle else f"ANGLE{'d' if to_degrees else 'r'}_{length}"

pandas_ta_classic/momentum/smi.py

@@ -37,9 +37,33 @@ def smi(close, fast=None, slow=None, signal=None, scalar=None, offset=None, **kw
         signalma.fillna(kwargs["fillna"], inplace=True)
         osc.fillna(kwargs["fillna"], inplace=True)
     if "fill_method" in kwargs:
-        smi.fillna(method=kwargs["fill_method"], inplace=True)
-        signalma.fillna(method=kwargs["fill_method"], inplace=True)
-        osc.fillna(method=kwargs["fill_method"], inplace=True)
+        if "fill_method" in kwargs:
+
+            if kwargs["fill_method"] == "ffill":
+
+                smi.ffill(inplace=True)
+
+            elif kwargs["fill_method"] == "bfill":
+
+                smi.bfill(inplace=True)
+        if "fill_method" in kwargs:
+
+            if kwargs["fill_method"] == "ffill":
+
+                signalma.ffill(inplace=True)
+
+            elif kwargs["fill_method"] == "bfill":
+
+                signalma.bfill(inplace=True)
+        if "fill_method" in kwargs:
+
+            if kwargs["fill_method"] == "ffill":
+
+                osc.ffill(inplace=True)
+
+            elif kwargs["fill_method"] == "bfill":
+
+                osc.bfill(inplace=True)
 
     # Name and Categorize it
     _scalar = f"_{scalar}" if scalar != 1 else ""

pandas_ta_classic/momentum/squeeze.py

@@ -77,10 +77,42 @@ def squeeze(high, low, close, bb_length=None, bb_std=None, kc_length=None, kc_sc
         squeeze_off.fillna(kwargs["fillna"], inplace=True)
         no_squeeze.fillna(kwargs["fillna"], inplace=True)
     if "fill_method" in kwargs:
-        squeeze.fillna(method=kwargs["fill_method"], inplace=True)
-        squeeze_on.fillna(method=kwargs["fill_method"], inplace=True)
-        squeeze_off.fillna(method=kwargs["fill_method"], inplace=True)
-        no_squeeze.fillna(method=kwargs["fill_method"], inplace=True)
+        if "fill_method" in kwargs:
+
+            if kwargs["fill_method"] == "ffill":
+
+                squeeze.ffill(inplace=True)
+
+            elif kwargs["fill_method"] == "bfill":
+
+                squeeze.bfill(inplace=True)
+        if "fill_method" in kwargs:
+
+            if kwargs["fill_method"] == "ffill":
+
+                squeeze_on.ffill(inplace=True)
+
+            elif kwargs["fill_method"] == "bfill":
+
+                squeeze_on.bfill(inplace=True)
+        if "fill_method" in kwargs:
+
+            if kwargs["fill_method"] == "ffill":
+
+                squeeze_off.ffill(inplace=True)
+
+            elif kwargs["fill_method"] == "bfill":
+
+                squeeze_off.bfill(inplace=True)
+        if "fill_method" in kwargs:
+
+            if kwargs["fill_method"] == "ffill":
+
+                no_squeeze.ffill(inplace=True)
+
+            elif kwargs["fill_method"] == "bfill":
+
+                no_squeeze.bfill(inplace=True)
 
     # Name and Categorize it
     _props = "" if use_tr else "hlr"
@@ -130,12 +162,60 @@ def squeeze(high, low, close, bb_length=None, bb_std=None, kc_length=None, kc_sc
             neg_dec.fillna(kwargs["fillna"], inplace=True)
             neg_inc.fillna(kwargs["fillna"], inplace=True)
         if "fill_method" in kwargs:
-            sqz_inc.fillna(method=kwargs["fill_method"], inplace=True)
-            sqz_dec.fillna(method=kwargs["fill_method"], inplace=True)
-            pos_inc.fillna(method=kwargs["fill_method"], inplace=True)
-            pos_dec.fillna(method=kwargs["fill_method"], inplace=True)
-            neg_dec.fillna(method=kwargs["fill_method"], inplace=True)
-            neg_inc.fillna(method=kwargs["fill_method"], inplace=True)
+            if "fill_method" in kwargs:
+
+                if kwargs["fill_method"] == "ffill":
+
+                    sqz_inc.ffill(inplace=True)
+
+                elif kwargs["fill_method"] == "bfill":
+
+                    sqz_inc.bfill(inplace=True)
+            if "fill_method" in kwargs:
+
+                if kwargs["fill_method"] == "ffill":
+
+                    sqz_dec.ffill(inplace=True)
+
+                elif kwargs["fill_method"] == "bfill":
+
+                    sqz_dec.bfill(inplace=True)
+            if "fill_method" in kwargs:
+
+                if kwargs["fill_method"] == "ffill":
+
+                    pos_inc.ffill(inplace=True)
+
+                elif kwargs["fill_method"] == "bfill":
+
+                    pos_inc.bfill(inplace=True)
+            if "fill_method" in kwargs:
+
+                if kwargs["fill_method"] == "ffill":
+
+                    pos_dec.ffill(inplace=True)
+
+                elif kwargs["fill_method"] == "bfill":
+
+                    pos_dec.bfill(inplace=True)
+            if "fill_method" in kwargs:
+
+                if kwargs["fill_method"] == "ffill":
+
+                    neg_dec.ffill(inplace=True)
+
+                elif kwargs["fill_method"] == "bfill":
+
+                    neg_dec.bfill(inplace=True)
+            if "fill_method" in kwargs:
+
+                if kwargs["fill_method"] == "ffill":
+
+                    neg_inc.ffill(inplace=True)
+
+                elif kwargs["fill_method"] == "bfill":
+
+                    neg_inc.bfill(inplace=True)
 
         df[f"SQZ_INC"] = sqz_inc
         df[f"SQZ_DEC"] = sqz_dec

pandas_ta_classic/momentum/squeeze_pro.py

@@ -84,12 +84,60 @@ def squeeze_pro(high, low, close, bb_length=None, bb_std=None, kc_length=None, k
         squeeze_off_wide.fillna(kwargs["fillna"], inplace=True)
         no_squeeze.fillna(kwargs["fillna"], inplace=True)
     if "fill_method" in kwargs:
-        squeeze.fillna(method=kwargs["fill_method"], inplace=True)
-        squeeze_on_wide.fillna(method=kwargs["fill_method"], inplace=True)
-        squeeze_on_normal.fillna(method=kwargs["fill_method"], inplace=True)
-        squeeze_on_narrow.fillna(method=kwargs["fill_method"], inplace=True)
-        squeeze_off_wide.fillna(method=kwargs["fill_method"], inplace=True)
-        no_squeeze.fillna(method=kwargs["fill_method"], inplace=True)
+        if "fill_method" in kwargs:
+
+            if kwargs["fill_method"] == "ffill":
+
+                squeeze.ffill(inplace=True)
+
+            elif kwargs["fill_method"] == "bfill":
+
+                squeeze.bfill(inplace=True)
+        if "fill_method" in kwargs:
+
+            if kwargs["fill_method"] == "ffill":
+
+                squeeze_on_wide.ffill(inplace=True)
+
+            elif kwargs["fill_method"] == "bfill":
+
+                squeeze_on_wide.bfill(inplace=True)
+        if "fill_method" in kwargs:
+
+            if kwargs["fill_method"] == "ffill":
+
+                squeeze_on_normal.ffill(inplace=True)
+
+            elif kwargs["fill_method"] == "bfill":
+
+                squeeze_on_normal.bfill(inplace=True)
+        if "fill_method" in kwargs:
+
+            if kwargs["fill_method"] == "ffill":
+
+                squeeze_on_narrow.ffill(inplace=True)
+
+            elif kwargs["fill_method"] == "bfill":
+
+                squeeze_on_narrow.bfill(inplace=True)
+        if "fill_method" in kwargs:
+
+            if kwargs["fill_method"] == "ffill":
+
+                squeeze_off_wide.ffill(inplace=True)
+
+            elif kwargs["fill_method"] == "bfill":
+
+                squeeze_off_wide.bfill(inplace=True)
+        if "fill_method" in kwargs:
+
+            if kwargs["fill_method"] == "ffill":
+
+                no_squeeze.ffill(inplace=True)
+
+            elif kwargs["fill_method"] == "bfill":
+
+                no_squeeze.bfill(inplace=True)
 
     # Name and Categorize it
     _props = "" if use_tr else "hlr"
@@ -140,12 +188,60 @@ def squeeze_pro(high, low, close, bb_length=None, bb_std=None, kc_length=None, k
             neg_dec.fillna(kwargs["fillna"], inplace=True)
             neg_inc.fillna(kwargs["fillna"], inplace=True)
         if "fill_method" in kwargs:
-            sqz_inc.fillna(method=kwargs["fill_method"], inplace=True)
-            sqz_dec.fillna(method=kwargs["fill_method"], inplace=True)
-            pos_inc.fillna(method=kwargs["fill_method"], inplace=True)
-            pos_dec.fillna(method=kwargs["fill_method"], inplace=True)
-            neg_dec.fillna(method=kwargs["fill_method"], inplace=True)
-            neg_inc.fillna(method=kwargs["fill_method"], inplace=True)
+            if "fill_method" in kwargs:
+
+                if kwargs["fill_method"] == "ffill":
+
+                    sqz_inc.ffill(inplace=True)
+
+                elif kwargs["fill_method"] == "bfill":
+
+                    sqz_inc.bfill(inplace=True)
+            if "fill_method" in kwargs:
+
+                if kwargs["fill_method"] == "ffill":
+
+                    sqz_dec.ffill(inplace=True)
+
+                elif kwargs["fill_method"] == "bfill":
+
+                    sqz_dec.bfill(inplace=True)
+            if "fill_method" in kwargs:
+
+                if kwargs["fill_method"] == "ffill":
+
+                    pos_inc.ffill(inplace=True)
+
+                elif kwargs["fill_method"] == "bfill":
+
+                    pos_inc.bfill(inplace=True)
+            if "fill_method" in kwargs:
+
+                if kwargs["fill_method"] == "ffill":
+
+                    pos_dec.ffill(inplace=True)
+
+                elif kwargs["fill_method"] == "bfill":
+
+                    pos_dec.bfill(inplace=True)
+            if "fill_method" in kwargs:
+
+                if kwargs["fill_method"] == "ffill":
+
+                    neg_dec.ffill(inplace=True)
+
+                elif kwargs["fill_method"] == "bfill":
+
+                    neg_dec.bfill(inplace=True)
+            if "fill_method" in kwargs:
+
+                if kwargs["fill_method"] == "ffill":
+
+                    neg_inc.ffill(inplace=True)
+
+                elif kwargs["fill_method"] == "bfill":
+
+                    neg_inc.bfill(inplace=True)
 
         df[f"SQZPRO_INC"] = sqz_inc
         df[f"SQZPRO_DEC"] = sqz_dec

pandas_ta_classic/momentum/stc.py

@@ -72,9 +72,33 @@ def stc(close, tclength=None, fast=None, slow=None, factor=None, offset=None, **
         macd.fillna(kwargs["fillna"], inplace=True)
         stoch.fillna(kwargs["fillna"], inplace=True)
     if "fill_method" in kwargs:
-        stc.fillna(method=kwargs["fill_method"], inplace=True)
-        macd.fillna(method=kwargs["fill_method"], inplace=True)
-        stoch.fillna(method=kwargs["fill_method"], inplace=True)
+        if "fill_method" in kwargs:
+
+            if kwargs["fill_method"] == "ffill":
+
+                stc.ffill(inplace=True)
+
+            elif kwargs["fill_method"] == "bfill":
+
+                stc.bfill(inplace=True)
+        if "fill_method" in kwargs:
+
+            if kwargs["fill_method"] == "ffill":
+
+                macd.ffill(inplace=True)
+
+            elif kwargs["fill_method"] == "bfill":
+
+                macd.bfill(inplace=True)
+        if "fill_method" in kwargs:
+
+            if kwargs["fill_method"] == "ffill":
+
+                stoch.ffill(inplace=True)
+
+            elif kwargs["fill_method"] == "bfill":
+
+                stoch.bfill(inplace=True)
 
     # Name and Categorize it
     _props = f"_{tclength}_{fast}_{slow}_{factor}"

pandas_ta_classic/momentum/stoch.py

@@ -39,8 +39,24 @@ def stoch(high, low, close, k=None, d=None, smooth_k=None, mamode=None, offset=N
         stoch_k.fillna(kwargs["fillna"], inplace=True)
         stoch_d.fillna(kwargs["fillna"], inplace=True)
     if "fill_method" in kwargs:
-        stoch_k.fillna(method=kwargs["fill_method"], inplace=True)
-        stoch_d.fillna(method=kwargs["fill_method"], inplace=True)
+        if "fill_method" in kwargs:
+
+            if kwargs["fill_method"] == "ffill":
+
+                stoch_k.ffill(inplace=True)
+
+            elif kwargs["fill_method"] == "bfill":
+
+                stoch_k.bfill(inplace=True)
+        if "fill_method" in kwargs:
+
+            if kwargs["fill_method"] == "ffill":
+
+                stoch_d.ffill(inplace=True)
+
+            elif kwargs["fill_method"] == "bfill":
+
+                stoch_d.bfill(inplace=True)
 
     # Name and Categorize it
     _name = "STOCH"

pandas_ta_classic/momentum/stochrsi.py

@@ -39,8 +39,24 @@ def stochrsi(close, length=None, rsi_length=None, k=None, d=None, mamode=None, o
         stochrsi_k.fillna(kwargs["fillna"], inplace=True)
         stochrsi_d.fillna(kwargs["fillna"], inplace=True)
     if "fill_method" in kwargs:
-        stochrsi_k.fillna(method=kwargs["fill_method"], inplace=True)
-        stochrsi_d.fillna(method=kwargs["fill_method"], inplace=True)
+        if "fill_method" in kwargs:
+
+            if kwargs["fill_method"] == "ffill":
+
+                stochrsi_k.ffill(inplace=True)
+
+            elif kwargs["fill_method"] == "bfill":
+
+                stochrsi_k.bfill(inplace=True)
+        if "fill_method" in kwargs:
+
+            if kwargs["fill_method"] == "ffill":
+
+                stochrsi_d.ffill(inplace=True)
+
+            elif kwargs["fill_method"] == "bfill":
+
+                stochrsi_d.bfill(inplace=True)
 
     # Name and Categorize it
     _name = "STOCHRSI"

pandas_ta_classic/momentum/td_seq.py

@@ -57,8 +57,24 @@ def td_seq(close, asint=None, offset=None, **kwargs):
         down_seq.fillna(kwargs["fillna"], inplace=True)
 
     if "fill_method" in kwargs:
-        up_seq.fillna(method=kwargs["fill_method"], inplace=True)
-        down_seq.fillna(method=kwargs["fill_method"], inplace=True)
+        if "fill_method" in kwargs:
+
+            if kwargs["fill_method"] == "ffill":
+
+                up_seq.ffill(inplace=True)
+
+            elif kwargs["fill_method"] == "bfill":
+
+                up_seq.bfill(inplace=True)
+        if "fill_method" in kwargs:
+
+            if kwargs["fill_method"] == "ffill":
+
+                down_seq.ffill(inplace=True)
+
+            elif kwargs["fill_method"] == "bfill":
+
+                down_seq.bfill(inplace=True)
 
     # Name & Category
     up_seq.name = f"TD_SEQ_UPa" if show_all else f"TD_SEQ_UP"

pandas_ta_classic/momentum/trix.py

@@ -34,8 +34,24 @@ def trix(close, length=None, signal=None, scalar=None, drift=None, offset=None,
         trix.fillna(kwargs["fillna"], inplace=True)
         trix_signal.fillna(kwargs["fillna"], inplace=True)
     if "fill_method" in kwargs:
-        trix.fillna(method=kwargs["fill_method"], inplace=True)
-        trix_signal.fillna(method=kwargs["fill_method"], inplace=True)
+        if "fill_method" in kwargs:
+
+            if kwargs["fill_method"] == "ffill":
+
+                trix.ffill(inplace=True)
+
+            elif kwargs["fill_method"] == "bfill":
+
+                trix.bfill(inplace=True)
+        if "fill_method" in kwargs:
+
+            if kwargs["fill_method"] == "ffill":
+
+                trix_signal.ffill(inplace=True)
+
+            elif kwargs["fill_method"] == "bfill":
+
+                trix_signal.bfill(inplace=True)
 
     # Name & Category
     trix.name = f"TRIX_{length}_{signal}"

pandas_ta_classic/momentum/tsi.py

@@ -43,8 +43,24 @@ def tsi(close, fast=None, slow=None, signal=None, scalar=None, mamode=None, drif
         tsi.fillna(kwargs["fillna"], inplace=True)
         tsi_signal.fillna(kwargs["fillna"], inplace=True)
     if "fill_method" in kwargs:
-        tsi.fillna(method=kwargs["fill_method"], inplace=True)
-        tsi_signal.fillna(method=kwargs["fill_method"], inplace=True)
+        if "fill_method" in kwargs:
+
+            if kwargs["fill_method"] == "ffill":
+
+                tsi.ffill(inplace=True)
+
+            elif kwargs["fill_method"] == "bfill":
+
+                tsi.bfill(inplace=True)
+        if "fill_method" in kwargs:
+
+            if kwargs["fill_method"] == "ffill":
+
+                tsi_signal.ffill(inplace=True)
+
+            elif kwargs["fill_method"] == "bfill":
+
+                tsi_signal.bfill(inplace=True)
 
     # Name and Categorize it
     tsi.name = f"TSI_{fast}_{slow}_{signal}"

pandas_ta_classic/momentum/uo.py

@@ -56,7 +56,15 @@ def uo(high, low, close, fast=None, medium=None, slow=None, fast_w=None, medium_
     if "fillna" in kwargs:
         uo.fillna(kwargs["fillna"], inplace=True)
     if "fill_method" in kwargs:
-        uo.fillna(method=kwargs["fill_method"], inplace=True)
+        if "fill_method" in kwargs:
+
+            if kwargs["fill_method"] == "ffill":
+
+                uo.ffill(inplace=True)
+
+            elif kwargs["fill_method"] == "bfill":
+
+                uo.bfill(inplace=True)
 
     # Name and Categorize it
     uo.name = f"UO_{fast}_{medium}_{slow}"

pandas_ta_classic/momentum/willr.py

@@ -35,7 +35,15 @@ def willr(high, low, close, length=None, talib=None, offset=None, **kwargs):
     if "fillna" in kwargs:
         willr.fillna(kwargs["fillna"], inplace=True)
     if "fill_method" in kwargs:
-        willr.fillna(method=kwargs["fill_method"], inplace=True)
+        if "fill_method" in kwargs:
+
+            if kwargs["fill_method"] == "ffill":
+
+                willr.ffill(inplace=True)
+
+            elif kwargs["fill_method"] == "bfill":
+
+                willr.bfill(inplace=True)
 
     # Name and Categorize it
     willr.name = f"WILLR_{length}"

pandas_ta_classic/overlap/alma.py

@@ -46,7 +46,15 @@ def alma(close, length=None, sigma=None, distribution_offset=None, offset=None,
     if "fillna" in kwargs:
         alma.fillna(kwargs["fillna"], inplace=True)
     if "fill_method" in kwargs:
-        alma.fillna(method=kwargs["fill_method"], inplace=True)
+        if "fill_method" in kwargs:
+
+            if kwargs["fill_method"] == "ffill":
+
+                alma.ffill(inplace=True)
+
+            elif kwargs["fill_method"] == "bfill":
+
+                alma.bfill(inplace=True)
 
     # Name & Category
     alma.name = f"ALMA_{length}_{sigma}_{distribution_offset}"

pandas_ta_classic/overlap/dema.py

@@ -31,7 +31,15 @@ def dema(close, length=None, talib=None, offset=None, **kwargs):
     if "fillna" in kwargs:
         dema.fillna(kwargs["fillna"], inplace=True)
     if "fill_method" in kwargs:
-        dema.fillna(method=kwargs["fill_method"], inplace=True)
+        if "fill_method" in kwargs:
+
+            if kwargs["fill_method"] == "ffill":
+
+                dema.ffill(inplace=True)
+
+            elif kwargs["fill_method"] == "bfill":
+
+                dema.bfill(inplace=True)
 
     # Name & Category
     dema.name = f"DEMA_{length}"

pandas_ta_classic/overlap/ema.py

@@ -36,7 +36,15 @@ def ema(close, length=None, talib=None, offset=None, **kwargs):
     if "fillna" in kwargs:
         ema.fillna(kwargs["fillna"], inplace=True)
     if "fill_method" in kwargs:
-        ema.fillna(method=kwargs["fill_method"], inplace=True)
+        if "fill_method" in kwargs:
+
+            if kwargs["fill_method"] == "ffill":
+
+                ema.ffill(inplace=True)
+
+            elif kwargs["fill_method"] == "bfill":
+
+                ema.bfill(inplace=True)
 
     # Name & Category
     ema.name = f"EMA_{length}"

pandas_ta_classic/overlap/fwma.py

@@ -24,7 +24,15 @@ def fwma(close, length=None, asc=None, offset=None, **kwargs):
     if "fillna" in kwargs:
         fwma.fillna(kwargs["fillna"], inplace=True)
     if "fill_method" in kwargs:
-        fwma.fillna(method=kwargs["fill_method"], inplace=True)
+        if "fill_method" in kwargs:
+
+            if kwargs["fill_method"] == "ffill":
+
+                fwma.ffill(inplace=True)
+
+            elif kwargs["fill_method"] == "bfill":
+
+                fwma.bfill(inplace=True)
 
     # Name & Category
     fwma.name = f"FWMA_{length}"

pandas_ta_classic/overlap/hilo.py

@@ -49,9 +49,33 @@ def hilo(high, low, close, high_length=None, low_length=None, mamode=None, offse
         long.fillna(kwargs["fillna"], inplace=True)
         short.fillna(kwargs["fillna"], inplace=True)
     if "fill_method" in kwargs:
-        hilo.fillna(method=kwargs["fill_method"], inplace=True)
-        long.fillna(method=kwargs["fill_method"], inplace=True)
-        short.fillna(method=kwargs["fill_method"], inplace=True)
+        if "fill_method" in kwargs:
+
+            if kwargs["fill_method"] == "ffill":
+
+                hilo.ffill(inplace=True)
+
+            elif kwargs["fill_method"] == "bfill":
+
+                hilo.bfill(inplace=True)
+        if "fill_method" in kwargs:
+
+            if kwargs["fill_method"] == "ffill":
+
+                long.ffill(inplace=True)
+
+            elif kwargs["fill_method"] == "bfill":
+
+                long.bfill(inplace=True)
+        if "fill_method" in kwargs:
+
+            if kwargs["fill_method"] == "ffill":
+
+                short.ffill(inplace=True)
+
+            elif kwargs["fill_method"] == "bfill":
+
+                short.bfill(inplace=True)
 
     # Name & Category
     _props = f"_{high_length}_{low_length}"

pandas_ta_classic/overlap/hma.py

@@ -29,7 +29,15 @@ def hma(close, length=None, offset=None, **kwargs):
     if "fillna" in kwargs:
         hma.fillna(kwargs["fillna"], inplace=True)
     if "fill_method" in kwargs:
-        hma.fillna(method=kwargs["fill_method"], inplace=True)
+        if "fill_method" in kwargs:
+
+            if kwargs["fill_method"] == "ffill":
+
+                hma.ffill(inplace=True)
+
+            elif kwargs["fill_method"] == "bfill":
+
+                hma.bfill(inplace=True)
 
     # Name & Category
     hma.name = f"HMA_{length}"

pandas_ta_classic/overlap/hwma.py

@@ -35,7 +35,15 @@ def hwma(close, na=None, nb=None, nc=None, offset=None, **kwargs):
     if "fillna" in kwargs:
         hwma.fillna(kwargs["fillna"], inplace=True)
     if "fill_method" in kwargs:
-        hwma.fillna(method=kwargs["fill_method"], inplace=True)
+        if "fill_method" in kwargs:
+
+            if kwargs["fill_method"] == "ffill":
+
+                hwma.ffill(inplace=True)
+
+            elif kwargs["fill_method"] == "bfill":
+
+                hwma.bfill(inplace=True)
 
     # Name & Category
     suffix = f"{na}_{nb}_{nc}"

pandas_ta_classic/overlap/ichimoku.py

@@ -47,9 +47,33 @@ def ichimoku(high, low, close, tenkan=None, kijun=None, senkou=None, include_chi
         span_b.fillna(kwargs["fillna"], inplace=True)
         chikou_span.fillna(kwargs["fillna"], inplace=True)
     if "fill_method" in kwargs:
-        span_a.fillna(method=kwargs["fill_method"], inplace=True)
-        span_b.fillna(method=kwargs["fill_method"], inplace=True)
-        chikou_span.fillna(method=kwargs["fill_method"], inplace=True)
+        if "fill_method" in kwargs:
+
+            if kwargs["fill_method"] == "ffill":
+
+                span_a.ffill(inplace=True)
+
+            elif kwargs["fill_method"] == "bfill":
+
+                span_a.bfill(inplace=True)
+        if "fill_method" in kwargs:
+
+            if kwargs["fill_method"] == "ffill":
+
+                span_b.ffill(inplace=True)
+
+            elif kwargs["fill_method"] == "bfill":
+
+                span_b.bfill(inplace=True)
+        if "fill_method" in kwargs:
+
+            if kwargs["fill_method"] == "ffill":
+
+                chikou_span.ffill(inplace=True)
+
+            elif kwargs["fill_method"] == "bfill":
+
+                chikou_span.bfill(inplace=True)
 
     # Name and Categorize it
     span_a.name = f"ISA_{tenkan}"

pandas_ta_classic/overlap/jma.py

@@ -84,7 +84,15 @@ def jma(close, length=None, phase=None, offset=None, **kwargs):
     if "fillna" in kwargs:
         jma.fillna(kwargs["fillna"], inplace=True)
     if "fill_method" in kwargs:
-        jma.fillna(method=kwargs["fill_method"], inplace=True)
+        if "fill_method" in kwargs:
+
+            if kwargs["fill_method"] == "ffill":
+
+                jma.ffill(inplace=True)
+
+            elif kwargs["fill_method"] == "bfill":
+
+                jma.bfill(inplace=True)
 
     # Name & Category
     jma.name = f"JMA_{_length}_{phase}"

pandas_ta_classic/overlap/kama.py

@@ -45,7 +45,15 @@ def kama(close, length=None, fast=None, slow=None, drift=None, offset=None, **kw
     if "fillna" in kwargs:
         kama.fillna(kwargs["fillna"], inplace=True)
     if "fill_method" in kwargs:
-        kama.fillna(method=kwargs["fill_method"], inplace=True)
+        if "fill_method" in kwargs:
+
+            if kwargs["fill_method"] == "ffill":
+
+                kama.ffill(inplace=True)
+
+            elif kwargs["fill_method"] == "bfill":
+
+                kama.bfill(inplace=True)
 
     # Name & Category
     kama.name = f"KAMA_{length}_{fast}_{slow}"

pandas_ta_classic/overlap/linreg.py

@@ -77,7 +77,15 @@ def linreg(close, length=None, offset=None, **kwargs):
     if "fillna" in kwargs:
         linreg.fillna(kwargs["fillna"], inplace=True)
     if "fill_method" in kwargs:
-        linreg.fillna(method=kwargs["fill_method"], inplace=True)
+        if "fill_method" in kwargs:
+
+            if kwargs["fill_method"] == "ffill":
+
+                linreg.ffill(inplace=True)
+
+            elif kwargs["fill_method"] == "bfill":
+
+                linreg.bfill(inplace=True)
 
     # Name and Categorize it
     linreg.name = f"LR"

pandas_ta_classic/overlap/mcgd.py

@@ -1,4 +1,5 @@
 # -*- coding: utf-8 -*-
+import pandas as pd
 from pandas_ta_classic.utils import get_offset, verify_series
 
 
@@ -21,7 +22,7 @@ def mcgd(close, length=None, offset=None, c=None, **kwargs):
         return series.iloc[1]
 
     mcg_cell = close[0:].rolling(2, min_periods=2).apply(mcg_, raw=False)
-    mcg_ds = close[:1].append(mcg_cell[1:])
+    mcg_ds = pd.concat([close[:1], mcg_cell[1:]])
 
     # Offset
     if offset != 0:
@@ -31,7 +32,10 @@ def mcgd(close, length=None, offset=None, c=None, **kwargs):
     if "fillna" in kwargs:
         mcg_ds.fillna(kwargs["fillna"], inplace=True)
     if "fill_method" in kwargs:
-        mcg_ds.fillna(method=kwargs["fill_method"], inplace=True)
+        if kwargs["fill_method"] == "ffill":
+            mcg_ds.ffill(inplace=True)
+        elif kwargs["fill_method"] == "bfill":
+            mcg_ds.bfill(inplace=True)
 
     # Name & Category
     mcg_ds.name = f"MCGD_{length}"
@@ -65,7 +69,7 @@ Calculation:
         series.iloc[1] = (series.iloc[0] + ((series.iloc[1] - series.iloc[0]) / denom))
         return series.iloc[1]
     mcg_cell = close[0:].rolling(2, min_periods=2).apply(mcg_, raw=False)
-    mcg_ds = close[:1].append(mcg_cell[1:])
+    mcg_ds = pd.concat([close[:1], mcg_cell[1:]])
 
 Args:
     close (pd.Series): Series of 'close's

pandas_ta_classic/overlap/midpoint.py

@@ -31,7 +31,15 @@ def midpoint(close, length=None, talib=None, offset=None, **kwargs):
     if "fillna" in kwargs:
         midpoint.fillna(kwargs["fillna"], inplace=True)
     if "fill_method" in kwargs:
-        midpoint.fillna(method=kwargs["fill_method"], inplace=True)
+        if "fill_method" in kwargs:
+
+            if kwargs["fill_method"] == "ffill":
+
+                midpoint.ffill(inplace=True)
+
+            elif kwargs["fill_method"] == "bfill":
+
+                midpoint.bfill(inplace=True)
 
     # Name and Categorize it
     midpoint.name = f"MIDPOINT_{length}"

pandas_ta_classic/overlap/midprice.py

@@ -33,7 +33,15 @@ def midprice(high, low, length=None, talib=None, offset=None, **kwargs):
     if "fillna" in kwargs:
         midprice.fillna(kwargs["fillna"], inplace=True)
     if "fill_method" in kwargs:
-        midprice.fillna(method=kwargs["fill_method"], inplace=True)
+        if "fill_method" in kwargs:
+
+            if kwargs["fill_method"] == "ffill":
+
+                midprice.ffill(inplace=True)
+
+            elif kwargs["fill_method"] == "bfill":
+
+                midprice.bfill(inplace=True)
 
     # Name and Categorize it
     midprice.name = f"MIDPRICE_{length}"

pandas_ta_classic/overlap/pwma.py

@@ -24,7 +24,15 @@ def pwma(close, length=None, asc=None, offset=None, **kwargs):
     if "fillna" in kwargs:
         pwma.fillna(kwargs["fillna"], inplace=True)
     if "fill_method" in kwargs:
-        pwma.fillna(method=kwargs["fill_method"], inplace=True)
+        if "fill_method" in kwargs:
+
+            if kwargs["fill_method"] == "ffill":
+
+                pwma.ffill(inplace=True)
+
+            elif kwargs["fill_method"] == "bfill":
+
+                pwma.bfill(inplace=True)
 
     # Name & Category
     pwma.name = f"PWMA_{length}"

pandas_ta_classic/overlap/rma.py

@@ -23,7 +23,15 @@ def rma(close, length=None, offset=None, **kwargs):
     if "fillna" in kwargs:
         rma.fillna(kwargs["fillna"], inplace=True)
     if "fill_method" in kwargs:
-        rma.fillna(method=kwargs["fill_method"], inplace=True)
+        if "fill_method" in kwargs:
+
+            if kwargs["fill_method"] == "ffill":
+
+                rma.ffill(inplace=True)
+
+            elif kwargs["fill_method"] == "bfill":
+
+                rma.bfill(inplace=True)
 
     # Name & Category
     rma.name = f"RMA_{length}"

pandas_ta_classic/overlap/sinwma.py

@@ -28,7 +28,15 @@ def sinwma(close, length=None, offset=None, **kwargs):
     if "fillna" in kwargs:
         sinwma.fillna(kwargs["fillna"], inplace=True)
     if "fill_method" in kwargs:
-        sinwma.fillna(method=kwargs["fill_method"], inplace=True)
+        if "fill_method" in kwargs:
+
+            if kwargs["fill_method"] == "ffill":
+
+                sinwma.ffill(inplace=True)
+
+            elif kwargs["fill_method"] == "bfill":
+
+                sinwma.bfill(inplace=True)
 
     # Name & Category
     sinwma.name = f"SINWMA_{length}"

pandas_ta_classic/overlap/sma.py

@@ -29,7 +29,15 @@ def sma(close, length=None, talib=None, offset=None, **kwargs):
     if "fillna" in kwargs:
         sma.fillna(kwargs["fillna"], inplace=True)
     if "fill_method" in kwargs:
-        sma.fillna(method=kwargs["fill_method"], inplace=True)
+        if "fill_method" in kwargs:
+
+            if kwargs["fill_method"] == "ffill":
+
+                sma.ffill(inplace=True)
+
+            elif kwargs["fill_method"] == "bfill":
+
+                sma.bfill(inplace=True)
 
     # Name & Category
     sma.name = f"SMA_{length}"

pandas_ta_classic/overlap/ssf.py

@@ -52,7 +52,15 @@ def ssf(close, length=None, poles=None, offset=None, **kwargs):
     if "fillna" in kwargs:
         ssf.fillna(kwargs["fillna"], inplace=True)
     if "fill_method" in kwargs:
-        ssf.fillna(method=kwargs["fill_method"], inplace=True)
+        if "fill_method" in kwargs:
+
+            if kwargs["fill_method"] == "ffill":
+
+                ssf.ffill(inplace=True)
+
+            elif kwargs["fill_method"] == "bfill":
+
+                ssf.bfill(inplace=True)
 
     # Name & Category
     ssf.name = f"SSF_{length}_{poles}"

pandas_ta_classic/overlap/supertrend.py

@@ -66,7 +66,15 @@ def supertrend(high, low, close, length=None, multiplier=None, offset=None, **kw
         df.fillna(kwargs["fillna"], inplace=True)
 
     if "fill_method" in kwargs:
-        df.fillna(method=kwargs["fill_method"], inplace=True)
+        if "fill_method" in kwargs:
+
+            if kwargs["fill_method"] == "ffill":
+
+                df.ffill(inplace=True)
+
+            elif kwargs["fill_method"] == "bfill":
+
+                df.bfill(inplace=True)
 
     return df
 

pandas_ta_classic/overlap/swma.py

@@ -26,7 +26,15 @@ def swma(close, length=None, asc=None, offset=None, **kwargs):
     if "fillna" in kwargs:
         swma.fillna(kwargs["fillna"], inplace=True)
     if "fill_method" in kwargs:
-        swma.fillna(method=kwargs["fill_method"], inplace=True)
+        if "fill_method" in kwargs:
+
+            if kwargs["fill_method"] == "ffill":
+
+                swma.ffill(inplace=True)
+
+            elif kwargs["fill_method"] == "bfill":
+
+                swma.bfill(inplace=True)
 
     # Name & Category
     swma.name = f"SWMA_{length}"

pandas_ta_classic/overlap/t3.py

@@ -41,7 +41,15 @@ def t3(close, length=None, a=None, talib=None, offset=None, **kwargs):
     if "fillna" in kwargs:
         t3.fillna(kwargs["fillna"], inplace=True)
     if "fill_method" in kwargs:
-        t3.fillna(method=kwargs["fill_method"], inplace=True)
+        if "fill_method" in kwargs:
+
+            if kwargs["fill_method"] == "ffill":
+
+                t3.ffill(inplace=True)
+
+            elif kwargs["fill_method"] == "bfill":
+
+                t3.bfill(inplace=True)
 
     # Name & Category
     t3.name = f"T3_{length}_{a}"

pandas_ta_classic/overlap/tema.py

@@ -32,7 +32,15 @@ def tema(close, length=None, talib=None, offset=None, **kwargs):
     if "fillna" in kwargs:
         tema.fillna(kwargs["fillna"], inplace=True)
     if "fill_method" in kwargs:
-        tema.fillna(method=kwargs["fill_method"], inplace=True)
+        if "fill_method" in kwargs:
+
+            if kwargs["fill_method"] == "ffill":
+
+                tema.ffill(inplace=True)
+
+            elif kwargs["fill_method"] == "bfill":
+
+                tema.bfill(inplace=True)
 
     # Name & Category
     tema.name = f"TEMA_{length}"

pandas_ta_classic/overlap/trima.py

@@ -31,7 +31,15 @@ def trima(close, length=None, talib=None, offset=None, **kwargs):
     if "fillna" in kwargs:
         trima.fillna(kwargs["fillna"], inplace=True)
     if "fill_method" in kwargs:
-        trima.fillna(method=kwargs["fill_method"], inplace=True)
+        if "fill_method" in kwargs:
+
+            if kwargs["fill_method"] == "ffill":
+
+                trima.ffill(inplace=True)
+
+            elif kwargs["fill_method"] == "bfill":
+
+                trima.bfill(inplace=True)
 
     # Name & Category
     trima.name = f"TRIMA_{length}"

pandas_ta_classic/overlap/vidya.py

@@ -45,7 +45,15 @@ def vidya(close, length=None, drift=None, offset=None, **kwargs):
     if "fillna" in kwargs:
         vidya.fillna(kwargs["fillna"], inplace=True)
     if "fill_method" in kwargs:
-        vidya.fillna(method=kwargs["fill_method"], inplace=True)
+        if "fill_method" in kwargs:
+
+            if kwargs["fill_method"] == "ffill":
+
+                vidya.ffill(inplace=True)
+
+            elif kwargs["fill_method"] == "bfill":
+
+                vidya.bfill(inplace=True)
 
     # Name & Category
     vidya.name = f"VIDYA_{length}"

pandas_ta_classic/overlap/vwap.py

@@ -31,7 +31,15 @@ def vwap(high, low, close, volume, anchor=None, offset=None, **kwargs):
     if "fillna" in kwargs:
         vwap.fillna(kwargs["fillna"], inplace=True)
     if "fill_method" in kwargs:
-        vwap.fillna(method=kwargs["fill_method"], inplace=True)
+        if "fill_method" in kwargs:
+
+            if kwargs["fill_method"] == "ffill":
+
+                vwap.ffill(inplace=True)
+
+            elif kwargs["fill_method"] == "bfill":
+
+                vwap.bfill(inplace=True)
 
     # Name & Category
     vwap.name = f"VWAP_{anchor}"

pandas_ta_classic/overlap/vwma.py

@@ -25,7 +25,15 @@ def vwma(close, volume, length=None, offset=None, **kwargs):
     if "fillna" in kwargs:
         vwma.fillna(kwargs["fillna"], inplace=True)
     if "fill_method" in kwargs:
-        vwma.fillna(method=kwargs["fill_method"], inplace=True)
+        if "fill_method" in kwargs:
+
+            if kwargs["fill_method"] == "ffill":
+
+                vwma.ffill(inplace=True)
+
+            elif kwargs["fill_method"] == "bfill":
+
+                vwma.bfill(inplace=True)
 
     # Name & Category
     vwma.name = f"VWMA_{length}"

pandas_ta_classic/overlap/wcp.py

@@ -27,7 +27,15 @@ def wcp(high, low, close, talib=None, offset=None, **kwargs):
     if "fillna" in kwargs:
         wcp.fillna(kwargs["fillna"], inplace=True)
     if "fill_method" in kwargs:
-        wcp.fillna(method=kwargs["fill_method"], inplace=True)
+        if "fill_method" in kwargs:
+
+            if kwargs["fill_method"] == "ffill":
+
+                wcp.ffill(inplace=True)
+
+            elif kwargs["fill_method"] == "bfill":
+
+                wcp.bfill(inplace=True)
 
     # Name & Category
     wcp.name = "WCP"

pandas_ta_classic/overlap/wma.py

@@ -43,7 +43,15 @@ def wma(close, length=None, asc=None, talib=None, offset=None, **kwargs):
     if "fillna" in kwargs:
         wma.fillna(kwargs["fillna"], inplace=True)
     if "fill_method" in kwargs:
-        wma.fillna(method=kwargs["fill_method"], inplace=True)
+        if "fill_method" in kwargs:
+
+            if kwargs["fill_method"] == "ffill":
+
+                wma.ffill(inplace=True)
+
+            elif kwargs["fill_method"] == "bfill":
+
+                wma.bfill(inplace=True)
 
     # Name & Category
     wma.name = f"WMA_{length}"

pandas_ta_classic/overlap/zlma.py

@@ -39,7 +39,15 @@ def zlma(close, length=None, mamode=None, offset=None, **kwargs):
     if "fillna" in kwargs:
         zlma.fillna(kwargs["fillna"], inplace=True)
     if "fill_method" in kwargs:
-        zlma.fillna(method=kwargs["fill_method"], inplace=True)
+        if "fill_method" in kwargs:
+
+            if kwargs["fill_method"] == "ffill":
+
+                zlma.ffill(inplace=True)
+
+            elif kwargs["fill_method"] == "bfill":
+
+                zlma.bfill(inplace=True)
 
     # Name & Category
     zlma.name = f"ZL_{zlma.name}"

pandas_ta_classic/performance/drawdown.py

@@ -33,9 +33,33 @@ def drawdown(close, offset=None, **kwargs) -> DataFrame:
         dd_pct.fillna(kwargs["fillna"], inplace=True)
         dd_log.fillna(kwargs["fillna"], inplace=True)
     if "fill_method" in kwargs:
-        dd.fillna(method=kwargs["fill_method"], inplace=True)
-        dd_pct.fillna(method=kwargs["fill_method"], inplace=True)
-        dd_log.fillna(method=kwargs["fill_method"], inplace=True)
+        if "fill_method" in kwargs:
+
+            if kwargs["fill_method"] == "ffill":
+
+                dd.ffill(inplace=True)
+
+            elif kwargs["fill_method"] == "bfill":
+
+                dd.bfill(inplace=True)
+        if "fill_method" in kwargs:
+
+            if kwargs["fill_method"] == "ffill":
+
+                dd_pct.ffill(inplace=True)
+
+            elif kwargs["fill_method"] == "bfill":
+
+                dd_pct.bfill(inplace=True)
+        if "fill_method" in kwargs:
+
+            if kwargs["fill_method"] == "ffill":
+
+                dd_log.ffill(inplace=True)
+
+            elif kwargs["fill_method"] == "bfill":
+
+                dd_log.bfill(inplace=True)
 
     # Name and Categorize it
     dd.name = "DD"

pandas_ta_classic/performance/log_return.py

@@ -28,7 +28,10 @@ def log_return(close, length=None, cumulative=None, offset=None, **kwargs):
     if "fillna" in kwargs:
         log_return.fillna(kwargs["fillna"], inplace=True)
     if "fill_method" in kwargs:
-        log_return.fillna(method=kwargs["fill_method"], inplace=True)
+        if kwargs["fill_method"] == "ffill":
+            log_return.ffill(inplace=True)
+        elif kwargs["fill_method"] == "bfill":
+            log_return.bfill(inplace=True)
 
     # Name & Category
     log_return.name = f"{'CUM' if cumulative else ''}LOGRET_{length}"

pandas_ta_classic/performance/percent_return.py

@@ -26,7 +26,15 @@ def percent_return(close, length=None, cumulative=None, offset=None, **kwargs):
     if "fillna" in kwargs:
         pct_return.fillna(kwargs["fillna"], inplace=True)
     if "fill_method" in kwargs:
-        pct_return.fillna(method=kwargs["fill_method"], inplace=True)
+        if "fill_method" in kwargs:
+
+            if kwargs["fill_method"] == "ffill":
+
+                pct_return.ffill(inplace=True)
+
+            elif kwargs["fill_method"] == "bfill":
+
+                pct_return.bfill(inplace=True)
 
     # Name & Category
     pct_return.name = f"{'CUM' if cumulative else ''}PCTRET_{length}"

pandas_ta_classic/statistics/entropy.py

@@ -25,7 +25,15 @@ def entropy(close, length=None, base=None, offset=None, **kwargs):
     if "fillna" in kwargs:
         entropy.fillna(kwargs["fillna"], inplace=True)
     if "fill_method" in kwargs:
-        entropy.fillna(method=kwargs["fill_method"], inplace=True)
+        if "fill_method" in kwargs:
+
+            if kwargs["fill_method"] == "ffill":
+
+                entropy.ffill(inplace=True)
+
+            elif kwargs["fill_method"] == "bfill":
+
+                entropy.bfill(inplace=True)
 
     # Name & Category
     entropy.name = f"ENTP_{length}"

pandas_ta_classic/statistics/kurtosis.py

@@ -23,7 +23,15 @@ def kurtosis(close, length=None, offset=None, **kwargs):
     if "fillna" in kwargs:
         kurtosis.fillna(kwargs["fillna"], inplace=True)
     if "fill_method" in kwargs:
-        kurtosis.fillna(method=kwargs["fill_method"], inplace=True)
+        if "fill_method" in kwargs:
+
+            if kwargs["fill_method"] == "ffill":
+
+                kurtosis.ffill(inplace=True)
+
+            elif kwargs["fill_method"] == "bfill":
+
+                kurtosis.bfill(inplace=True)
 
     # Name & Category
     kurtosis.name = f"KURT_{length}"

pandas_ta_classic/statistics/mad.py

@@ -28,7 +28,15 @@ def mad(close, length=None, offset=None, **kwargs):
     if "fillna" in kwargs:
         mad.fillna(kwargs["fillna"], inplace=True)
     if "fill_method" in kwargs:
-        mad.fillna(method=kwargs["fill_method"], inplace=True)
+        if "fill_method" in kwargs:
+
+            if kwargs["fill_method"] == "ffill":
+
+                mad.ffill(inplace=True)
+
+            elif kwargs["fill_method"] == "bfill":
+
+                mad.bfill(inplace=True)
 
     # Name & Category
     mad.name = f"MAD_{length}"

pandas_ta_classic/statistics/median.py

@@ -23,7 +23,15 @@ def median(close, length=None, offset=None, **kwargs):
     if "fillna" in kwargs:
         median.fillna(kwargs["fillna"], inplace=True)
     if "fill_method" in kwargs:
-        median.fillna(method=kwargs["fill_method"], inplace=True)
+        if "fill_method" in kwargs:
+
+            if kwargs["fill_method"] == "ffill":
+
+                median.ffill(inplace=True)
+
+            elif kwargs["fill_method"] == "bfill":
+
+                median.bfill(inplace=True)
 
     # Name & Category
     median.name = f"MEDIAN_{length}"

pandas_ta_classic/statistics/quantile.py

@@ -24,7 +24,15 @@ def quantile(close, length=None, q=None, offset=None, **kwargs):
     if "fillna" in kwargs:
         quantile.fillna(kwargs["fillna"], inplace=True)
     if "fill_method" in kwargs:
-        quantile.fillna(method=kwargs["fill_method"], inplace=True)
+        if "fill_method" in kwargs:
+
+            if kwargs["fill_method"] == "ffill":
+
+                quantile.ffill(inplace=True)
+
+            elif kwargs["fill_method"] == "bfill":
+
+                quantile.bfill(inplace=True)
 
     # Name & Category
     quantile.name = f"QTL_{length}_{q}"

pandas_ta_classic/statistics/skew.py

@@ -23,7 +23,15 @@ def skew(close, length=None, offset=None, **kwargs):
     if "fillna" in kwargs:
         skew.fillna(kwargs["fillna"], inplace=True)
     if "fill_method" in kwargs:
-        skew.fillna(method=kwargs["fill_method"], inplace=True)
+        if "fill_method" in kwargs:
+
+            if kwargs["fill_method"] == "ffill":
+
+                skew.ffill(inplace=True)
+
+            elif kwargs["fill_method"] == "bfill":
+
+                skew.bfill(inplace=True)
 
     # Name & Category
     skew.name = f"SKEW_{length}"

pandas_ta_classic/statistics/stdev.py

@@ -31,7 +31,15 @@ def stdev(close, length=None, ddof=None, talib=None, offset=None, **kwargs):
     if "fillna" in kwargs:
         stdev.fillna(kwargs["fillna"], inplace=True)
     if "fill_method" in kwargs:
-        stdev.fillna(method=kwargs["fill_method"], inplace=True)
+        if "fill_method" in kwargs:
+
+            if kwargs["fill_method"] == "ffill":
+
+                stdev.ffill(inplace=True)
+
+            elif kwargs["fill_method"] == "bfill":
+
+                stdev.bfill(inplace=True)
 
     # Name & Category
     stdev.name = f"STDEV_{length}"

pandas_ta_classic/statistics/tos_stdevall.py

@@ -55,7 +55,15 @@ def tos_stdevall(close, length=None, stds=None, ddof=None, offset=None, **kwargs
     if "fillna" in kwargs:
         df.fillna(kwargs["fillna"], inplace=True)
     if "fill_method" in kwargs:
-        df.fillna(method=kwargs["fill_method"], inplace=True)
+        if "fill_method" in kwargs:
+
+            if kwargs["fill_method"] == "ffill":
+
+                df.ffill(inplace=True)
+
+            elif kwargs["fill_method"] == "bfill":
+
+                df.bfill(inplace=True)
 
     # Prepare DataFrame to return
     df.name = f"{_props}"

pandas_ta_classic/statistics/variance.py

@@ -30,7 +30,15 @@ def variance(close, length=None, ddof=None, talib=None, offset=None, **kwargs):
     if "fillna" in kwargs:
         variance.fillna(kwargs["fillna"], inplace=True)
     if "fill_method" in kwargs:
-        variance.fillna(method=kwargs["fill_method"], inplace=True)
+        if "fill_method" in kwargs:
+
+            if kwargs["fill_method"] == "ffill":
+
+                variance.ffill(inplace=True)
+
+            elif kwargs["fill_method"] == "bfill":
+
+                variance.bfill(inplace=True)
 
     # Name & Category
     variance.name = f"VAR_{length}"

pandas_ta_classic/statistics/zscore.py

@@ -27,7 +27,15 @@ def zscore(close, length=None, std=None, offset=None, **kwargs):
     if "fillna" in kwargs:
         zscore.fillna(kwargs["fillna"], inplace=True)
     if "fill_method" in kwargs:
-        zscore.fillna(method=kwargs["fill_method"], inplace=True)
+        if "fill_method" in kwargs:
+
+            if kwargs["fill_method"] == "ffill":
+
+                zscore.ffill(inplace=True)
+
+            elif kwargs["fill_method"] == "bfill":
+
+                zscore.bfill(inplace=True)
 
     # Name & Category
     zscore.name = f"ZS_{length}"

pandas_ta_classic/trend/adx.py

@@ -51,9 +51,33 @@ def adx(high, low, close, length=None, lensig=None, scalar=None, mamode=None, dr
         dmp.fillna(kwargs["fillna"], inplace=True)
         dmn.fillna(kwargs["fillna"], inplace=True)
     if "fill_method" in kwargs:
-        adx.fillna(method=kwargs["fill_method"], inplace=True)
-        dmp.fillna(method=kwargs["fill_method"], inplace=True)
-        dmn.fillna(method=kwargs["fill_method"], inplace=True)
+        if "fill_method" in kwargs:
+
+            if kwargs["fill_method"] == "ffill":
+
+                adx.ffill(inplace=True)
+
+            elif kwargs["fill_method"] == "bfill":
+
+                adx.bfill(inplace=True)
+        if "fill_method" in kwargs:
+
+            if kwargs["fill_method"] == "ffill":
+
+                dmp.ffill(inplace=True)
+
+            elif kwargs["fill_method"] == "bfill":
+
+                dmp.bfill(inplace=True)
+        if "fill_method" in kwargs:
+
+            if kwargs["fill_method"] == "ffill":
+
+                dmn.ffill(inplace=True)
+
+            elif kwargs["fill_method"] == "bfill":
+
+                dmn.bfill(inplace=True)
 
     # Name and Categorize it
     adx.name = f"ADX_{lensig}"

pandas_ta_classic/trend/amat.py

@@ -37,8 +37,24 @@ def amat(close=None, fast=None, slow=None, lookback=None, mamode=None, offset=No
         mas_short.fillna(kwargs["fillna"], inplace=True)
 
     if "fill_method" in kwargs:
-        mas_long.fillna(method=kwargs["fill_method"], inplace=True)
-        mas_short.fillna(method=kwargs["fill_method"], inplace=True)
+        if "fill_method" in kwargs:
+
+            if kwargs["fill_method"] == "ffill":
+
+                mas_long.ffill(inplace=True)
+
+            elif kwargs["fill_method"] == "bfill":
+
+                mas_long.bfill(inplace=True)
+        if "fill_method" in kwargs:
+
+            if kwargs["fill_method"] == "ffill":
+
+                mas_short.ffill(inplace=True)
+
+            elif kwargs["fill_method"] == "bfill":
+
+                mas_short.bfill(inplace=True)
 
     # Prepare DataFrame to return
     amatdf = DataFrame({

pandas_ta_classic/trend/aroon.py

@@ -37,9 +37,33 @@ def aroon(high, low, length=None, scalar=None, talib=None, offset=None, **kwargs
         aroon_down.fillna(kwargs["fillna"], inplace=True)
         aroon_osc.fillna(kwargs["fillna"], inplace=True)
     if "fill_method" in kwargs:
-        aroon_up.fillna(method=kwargs["fill_method"], inplace=True)
-        aroon_down.fillna(method=kwargs["fill_method"], inplace=True)
-        aroon_osc.fillna(method=kwargs["fill_method"], inplace=True)
+        if "fill_method" in kwargs:
+
+            if kwargs["fill_method"] == "ffill":
+
+                aroon_up.ffill(inplace=True)
+
+            elif kwargs["fill_method"] == "bfill":
+
+                aroon_up.bfill(inplace=True)
+        if "fill_method" in kwargs:
+
+            if kwargs["fill_method"] == "ffill":
+
+                aroon_down.ffill(inplace=True)
+
+            elif kwargs["fill_method"] == "bfill":
+
+                aroon_down.bfill(inplace=True)
+        if "fill_method" in kwargs:
+
+            if kwargs["fill_method"] == "ffill":
+
+                aroon_osc.ffill(inplace=True)
+
+            elif kwargs["fill_method"] == "bfill":
+
+                aroon_osc.bfill(inplace=True)
 
     # Offset
     if offset != 0:

pandas_ta_classic/trend/chop.py

@@ -40,7 +40,15 @@ def chop(high, low, close, length=None, atr_length=None, ln=None, scalar=None, d
     if "fillna" in kwargs:
         chop.fillna(kwargs["fillna"], inplace=True)
     if "fill_method" in kwargs:
-        chop.fillna(method=kwargs["fill_method"], inplace=True)
+        if "fill_method" in kwargs:
+
+            if kwargs["fill_method"] == "ffill":
+
+                chop.ffill(inplace=True)
+
+            elif kwargs["fill_method"] == "bfill":
+
+                chop.bfill(inplace=True)
 
     # Name and Categorize it
     chop.name = f"CHOP{'ln' if ln else ''}_{length}_{atr_length}_{scalar}"

pandas_ta_classic/trend/cksp.py

@@ -41,8 +41,24 @@ def cksp(high, low, close, p=None, x=None, q=None, tvmode=None, offset=None, **k
         long_stop.fillna(kwargs["fillna"], inplace=True)
         short_stop.fillna(kwargs["fillna"], inplace=True)
     if "fill_method" in kwargs:
-        long_stop.fillna(method=kwargs["fill_method"], inplace=True)
-        short_stop.fillna(method=kwargs["fill_method"], inplace=True)
+        if "fill_method" in kwargs:
+
+            if kwargs["fill_method"] == "ffill":
+
+                long_stop.ffill(inplace=True)
+
+            elif kwargs["fill_method"] == "bfill":
+
+                long_stop.bfill(inplace=True)
+        if "fill_method" in kwargs:
+
+            if kwargs["fill_method"] == "ffill":
+
+                short_stop.ffill(inplace=True)
+
+            elif kwargs["fill_method"] == "bfill":
+
+                short_stop.bfill(inplace=True)
 
     # Name and Categorize it
     _props = f"_{p}_{x}_{q}"

pandas_ta_classic/trend/decay.py

@@ -33,7 +33,15 @@ def decay(close, kind=None, length=None, mode=None, offset=None, **kwargs):
     if "fillna" in kwargs:
         ld.fillna(kwargs["fillna"], inplace=True)
     if "fill_method" in kwargs:
-        ld.fillna(method=kwargs["fill_method"], inplace=True)
+        if "fill_method" in kwargs:
+
+            if kwargs["fill_method"] == "ffill":
+
+                ld.ffill(inplace=True)
+
+            elif kwargs["fill_method"] == "bfill":
+
+                ld.bfill(inplace=True)
 
     # Name and Categorize it
     ld.name = f"{_mode}DECAY_{length}"

pandas_ta_classic/trend/decreasing.py

@@ -38,7 +38,15 @@ def decreasing(close, length=None, strict=None, asint=None, percent=None, drift=
     if "fillna" in kwargs:
         decreasing.fillna(kwargs["fillna"], inplace=True)
     if "fill_method" in kwargs:
-        decreasing.fillna(method=kwargs["fill_method"], inplace=True)
+        if "fill_method" in kwargs:
+
+            if kwargs["fill_method"] == "ffill":
+
+                decreasing.ffill(inplace=True)
+
+            elif kwargs["fill_method"] == "bfill":
+
+                decreasing.bfill(inplace=True)
 
     # Name and Categorize it
     _percent = f"_{0.01 * percent}" if percent else ''

pandas_ta_classic/trend/dpo.py

@@ -30,7 +30,15 @@ def dpo(close, length=None, centered=True, offset=None, **kwargs):
     if "fillna" in kwargs:
         dpo.fillna(kwargs["fillna"], inplace=True)
     if "fill_method" in kwargs:
-        dpo.fillna(method=kwargs["fill_method"], inplace=True)
+        if "fill_method" in kwargs:
+
+            if kwargs["fill_method"] == "ffill":
+
+                dpo.ffill(inplace=True)
+
+            elif kwargs["fill_method"] == "bfill":
+
+                dpo.bfill(inplace=True)
 
     # Name and Categorize it
     dpo.name = f"DPO_{length}"

pandas_ta_classic/trend/increasing.py

@@ -38,7 +38,15 @@ def increasing(close, length=None, strict=None, asint=None, percent=None, drift=
     if "fillna" in kwargs:
         increasing.fillna(kwargs["fillna"], inplace=True)
     if "fill_method" in kwargs:
-        increasing.fillna(method=kwargs["fill_method"], inplace=True)
+        if "fill_method" in kwargs:
+
+            if kwargs["fill_method"] == "ffill":
+
+                increasing.ffill(inplace=True)
+
+            elif kwargs["fill_method"] == "bfill":
+
+                increasing.bfill(inplace=True)
 
     # Name and Categorize it
     _percent = f"_{0.01 * percent}" if percent else ''

pandas_ta_classic/trend/long_run.py

@@ -27,7 +27,15 @@ def long_run(fast, slow, length=None, offset=None, **kwargs):
     if "fillna" in kwargs:
         long_run.fillna(kwargs["fillna"], inplace=True)
     if "fill_method" in kwargs:
-        long_run.fillna(method=kwargs["fill_method"], inplace=True)
+        if "fill_method" in kwargs:
+
+            if kwargs["fill_method"] == "ffill":
+
+                long_run.ffill(inplace=True)
+
+            elif kwargs["fill_method"] == "bfill":
+
+                long_run.bfill(inplace=True)
 
     # Name and Categorize it
     long_run.name = f"LR_{length}"

pandas_ta_classic/trend/psar.py

@@ -97,10 +97,42 @@ def psar(high, low, close=None, af0=None, af=None, max_af=None, offset=None, **k
         short.fillna(kwargs["fillna"], inplace=True)
         reversal.fillna(kwargs["fillna"], inplace=True)
     if "fill_method" in kwargs:
-        _af.fillna(method=kwargs["fill_method"], inplace=True)
-        long.fillna(method=kwargs["fill_method"], inplace=True)
-        short.fillna(method=kwargs["fill_method"], inplace=True)
-        reversal.fillna(method=kwargs["fill_method"], inplace=True)
+        if "fill_method" in kwargs:
+
+            if kwargs["fill_method"] == "ffill":
+
+                _af.ffill(inplace=True)
+
+            elif kwargs["fill_method"] == "bfill":
+
+                _af.bfill(inplace=True)
+        if "fill_method" in kwargs:
+
+            if kwargs["fill_method"] == "ffill":
+
+                long.ffill(inplace=True)
+
+            elif kwargs["fill_method"] == "bfill":
+
+                long.bfill(inplace=True)
+        if "fill_method" in kwargs:
+
+            if kwargs["fill_method"] == "ffill":
+
+                short.ffill(inplace=True)
+
+            elif kwargs["fill_method"] == "bfill":
+
+                short.bfill(inplace=True)
+        if "fill_method" in kwargs:
+
+            if kwargs["fill_method"] == "ffill":
+
+                reversal.ffill(inplace=True)
+
+            elif kwargs["fill_method"] == "bfill":
+
+                reversal.bfill(inplace=True)
 
     # Prepare DataFrame to return
     _params = f"_{af0}_{max_af}"