quantmod 0.0.4__tar.gz → 0.0.5__tar.gz

{quantmod-0.0.4 → quantmod-0.0.5}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.2
 Name: quantmod
-Version: 0.0.4
+Version: 0.0.5
 Summary: Quantmod Python Package
 Home-page: https://kannansingaravelu.com/
 Author: Kannan Singaravelu
@@ -9,7 +9,6 @@ License: Apache License 2.0
 Keywords: python,quant,quantmod,quantmod-python
 Platform: any
 Classifier: License :: OSI Approved :: Apache Software License
-Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Operating System :: OS Independent
 Classifier: Intended Audience :: Developers
@@ -20,13 +19,29 @@ Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE.txt
+Requires-Dist: joblib
+Requires-Dist: jugaad-data
+Requires-Dist: matplotlib
 Requires-Dist: numpy>=2.0.2
 Requires-Dist: pandas>=2.2.2
 Requires-Dist: pydantic>=2.8.2
 Requires-Dist: scipy>=1.13.1
+Requires-Dist: sqlalchemy>=2.0.38
 Requires-Dist: tabulate>=0.9.0
 Requires-Dist: urllib3==1.26.15
 Requires-Dist: yfinance>=0.2.43
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: keywords
+Dynamic: license
+Dynamic: platform
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
 
 
 Quantmod Python package is inspired by the quantmod package for R. This new tool is designed to assist quantitative traders and data analysts with the development, testing, and rapid prototyping of trading strategies. quantmod features a straightforward and intuitive interface aimed at simplifying workflows and boosting productivity.

{quantmod-0.0.4 → quantmod-0.0.5}/quantmod/__init__.py

@@ -23,14 +23,7 @@
 from . import version
 from .main import hello
 
-from quantmod import (
-    derivatives, 
-    indicators,
-    markets, 
-    models,  
-    timeseries,
-    datasets
-)
+from quantmod import derivatives, indicators, markets, models, timeseries, datasets
 
 
 __all__ = [
@@ -40,8 +33,8 @@ __all__ = [
     "markets",
     "models",
     "timeseries",
-    "datasets"
+    "datasets",
 ]
 
 __version__ = version.version
-__author__ = "Kannan Singaravelu"
+__author__ = "Kannan Singaravelu"

{quantmod-0.0.4 → quantmod-0.0.5}/quantmod/derivatives/__init__.py

@@ -16,8 +16,6 @@
 # limitations under the License.
 #
 
-from .options import maxpain
+from .optionchain import OptionChain
 
-__all__ = [
-    "maxpain",
-]
+__all__ = ["OptionChain"]

quantmod-0.0.5/quantmod/derivatives/optionchain.py

@@ -0,0 +1,249 @@
+import pandas as pd
+import numpy as np
+from jugaad_data.nse import NSELive
+
+
+# construct a class object
+class OptionChain:
+    """
+    A class to fetch and process option chain data from NSE (National Stock Exchange).
+
+    Parameters
+    ----------
+    symbol : str
+        Trading symbol (e.g., 'NIFTY', 'BANKNIFTY' or any equity symbol)
+    expiry_date : str
+        Expiry date of the options
+
+    Attributes
+    ----------
+    option_chain : pandas.DataFrame
+        Processed option chain data
+    call_option_data : pandas.DataFrame
+        Call options data
+    put_option_date : pandas.DataFrame
+        Put options data
+    option_pain : float
+        Maximum pain strike price
+
+    Methods
+    -------
+    get_option_price()
+        Get the option price (last traded, bid, or ask) for a specific option
+    get_synthetic_futures()
+        Calculate synthetic futures price for a given strike price
+    """
+
+    def __init__(self, symbol, expiry_date):
+        self.n = NSELive()
+        self.symbol = symbol
+        self.expiry_date = expiry_date
+
+        # flatten json and convert to dataframe
+        if symbol in ["NIFTY", "BANKNIFTY"]:
+            df = self.n.index_option_chain(self.symbol)["records"]["data"]
+        else:
+            df = self.n.equities_option_chain(self.symbol)["records"]["data"]
+        df = pd.json_normalize(df).fillna(0)
+        self.df = df[df["expiryDate"] == self.expiry_date]
+
+        # the __dict__ attributes
+        self.option_chain = self._get_option_chain()
+        self.call_option_data = self._get_call_option_data()
+        self.put_option_data = self._get_put_option_data()
+        self.option_pain = self._get_option_pain()
+
+    # get option chain
+    def _get_option_chain(self):
+        """
+        Retrieve the complete option chain data.
+
+        Returns
+        -------
+        pandas.DataFrame
+            Complete option chain data for the specified symbol and expiry
+        """
+        return self.df
+
+    # Create function to get call and put options
+    def _get_call_option_data(self):
+        """
+        Extract and process call option data from the option chain.
+
+        Returns
+        -------
+        pandas.DataFrame
+            Processed call options data with simplified column names
+        """
+        calls = self.option_chain.iloc[:, 21:].reset_index(drop=True)
+        cols = [i[3:] for i in calls.columns]
+        calls.columns = cols
+        return calls
+
+    def _get_put_option_data(self):
+        """
+        Extract and process put option data from the option chain.
+
+        Returns
+        -------
+        pandas.DataFrame
+            Processed put options data with simplified column names
+        """
+        puts = self.option_chain.iloc[:, 2:21].reset_index(drop=True)
+        cols = [i[3:] for i in puts.columns]
+        puts.columns = cols
+        return puts
+
+    # get option price
+    def get_option_price(self, strike, opt_type, txn_type=None):
+        """
+        Get the option price (last traded, bid, or ask) for a specific option.
+
+        Parameters
+        ----------
+        strike : float
+            Strike price of the option
+        opt_type : str
+            Option type ('CE' for Call or 'PE' for Put)
+        txn_type : str, optional
+            Transaction type ('buy', 'sell', or None for last price)
+
+        Returns
+        -------
+        float
+            Option price based on the specified parameters
+        """
+        price_type = (
+            "bidprice"
+            if txn_type == "sell"
+            else "askPrice"
+            if txn_type == "buy"
+            else "lastPrice"
+        )
+        col = f"{opt_type}.{price_type}"
+
+        return float(self.df[self.df["strikePrice"] == strike][col].iloc[0])
+
+    # get synthetic futures
+    def get_synthetic_futures(self, strike):
+        """
+        Calculate synthetic futures price for a given strike price.
+        Synthetic Futures price = Strike + Call - Put
+
+        Parameters
+        ----------
+        strike : float
+            Strike price for which to calculate synthetic futures
+
+        Returns
+        -------
+        float
+            Synthetic futures price
+        """
+        return (
+            strike
+            + self.get_option_price(strike, opt_type="CE", txn_type="buy")
+            - self.get_option_price(strike, opt_type="PE", txn_type="sell")
+        )
+
+    def _get_option_pain(self) -> float:
+        """
+        Calculate the maximum pain point - the strike price where the total value of all
+        options (calls and puts) would cause the most financial pain to option writers.
+
+        Returns
+        -------
+        float
+            Strike price at which maximum pain occurs
+        """
+        # Get data from class attributes
+        strikes = np.array(self.option_chain["strikePrice"], dtype=float)
+        call_oi = np.array(self.call_option_data["openInterest"], dtype=float)
+        put_oi = np.array(self.put_option_data["openInterest"], dtype=float)
+
+        # Calculate pain for each possible expiry price
+        total_pain = []
+
+        for expiry_price in strikes:
+            # Calculate call options pain
+            call_pain = sum(
+                call_oi[i] * max(0, expiry_price - strike)
+                for i, strike in enumerate(strikes)
+            )
+
+            # Calculate put options pain
+            put_pain = sum(
+                put_oi[i] * max(0, strike - expiry_price)
+                for i, strike in enumerate(strikes)
+            )
+
+            # Total pain at this price level
+            total_pain.append(call_pain + put_pain)
+
+        # Find strike with minimum pain
+        max_pain_index = np.argmin(total_pain)
+        return float(strikes[max_pain_index])
+
+    def plot_pain_analysis(self):
+        """
+        Plot pain analysis for the option chain.
+        """
+        # Get data from class attributes
+        strikes = np.array(self.option_chain["strikePrice"], dtype=float)
+        call_oi = np.array(self.call_option_data["openInterest"], dtype=float)
+        put_oi = np.array(self.put_option_data["openInterest"], dtype=float)
+
+        results = []
+
+        for expiry_price in strikes:
+            # Calculate call options pain
+            call_pain = sum(
+                call_oi[i] * max(0, expiry_price - strike)
+                for i, strike in enumerate(strikes)
+            )
+
+            # Calculate put options pain
+            put_pain = sum(
+                put_oi[i] * max(0, strike - expiry_price)
+                for i, strike in enumerate(strikes)
+            )
+
+            results.append(
+                {
+                    "Strike": expiry_price,
+                    "Call Pain": call_pain,
+                    "Put Pain": put_pain,
+                    "Total Pain": call_pain + put_pain,
+                }
+            )
+
+        analysis = pd.DataFrame(results)
+        # Plot the pain distribution (requires matplotlib)
+        try:
+            import matplotlib.pyplot as plt
+
+            plt.figure(figsize=(10, 6))
+            plt.plot(
+                analysis["Strike"], analysis["Total Pain"], "b-", label="Total Pain"
+            )
+            plt.plot(
+                analysis["Strike"], analysis["Call Pain"], "g--", label="Call Pain"
+            )
+            plt.plot(analysis["Strike"], analysis["Put Pain"], "r--", label="Put Pain")
+            plt.axvline(
+                x=self._get_option_pain(),
+                color="k",
+                linestyle=":",
+                label=f"Max Pain Strike: {self._get_option_pain():}",
+            )
+
+            plt.title("Option Pain Analysis")
+            plt.xlabel("Strike Price")
+            plt.ylabel("Pain Value")
+            plt.legend()
+            plt.grid(True)
+
+        except ImportError:
+            print("\nMatplotlib not installed. Skipping plot generation.")
+
+        plt.show()

{quantmod-0.0.4 → quantmod-0.0.5}/quantmod/indicators/indicators.py

@@ -1,5 +1,6 @@
 import pandas as pd
 
+
 def ATR(df: pd.DataFrame, lookback: int = 14) -> pd.Series:
     """
     Calculate the Average True Range (ATR).
@@ -20,20 +21,20 @@ def ATR(df: pd.DataFrame, lookback: int = 14) -> pd.Series:
     pd.Series
         series containing the ATR values for each period
     """
-    
+
     df = df.copy()
     df.rename(columns=str.lower, inplace=True)
-    
-    df['H-L']=abs(df['high']-df['low'])
-    df['H-PC']=abs(df['high']-df['close'].shift(1))
-    df['L-PC']=abs(df['low']-df['close'].shift(1))
-   
-    df['TR']=df[['H-L','H-PC','L-PC']].max(axis=1,skipna=False)
-    df['ATR']=df['TR'].rolling(lookback).mean()
-    
-    data = df.drop(['H-L','H-PC','L-PC'],axis=1) # drop columns
-    
-    return data['ATR']
+
+    df["H-L"] = abs(df["high"] - df["low"])
+    df["H-PC"] = abs(df["high"] - df["close"].shift(1))
+    df["L-PC"] = abs(df["low"] - df["close"].shift(1))
+
+    df["TR"] = df[["H-L", "H-PC", "L-PC"]].max(axis=1, skipna=False)
+    df["ATR"] = df["TR"].rolling(lookback).mean()
+
+    data = df.drop(["H-L", "H-PC", "L-PC"], axis=1)  # drop columns
+
+    return data["ATR"]
 
 
 def BBands(series: pd.Series, lookback: int, multiplier: float = 2) -> pd.Series:
@@ -77,7 +78,7 @@ def SMA(series: pd.Series, lookback: int) -> pd.Series:
         time series to calculate the Moving Average for
     lookback : int
         lookback period for the Moving Average
-        
+
     Returns
     -------
     pd.Series
@@ -86,6 +87,7 @@ def SMA(series: pd.Series, lookback: int) -> pd.Series:
 
     return series.rolling(lookback).mean()
 
+
 def EMA(series: pd.Series, lookback: int) -> pd.Series:
     """
     Exponential Moving Average
@@ -96,7 +98,7 @@ def EMA(series: pd.Series, lookback: int) -> pd.Series:
         time series to calculate the Exponential Moving Average for
     lookback : int
         lookback period for the Exponential Moving Average
-        
+
     Returns
     -------
     pd.Series
@@ -120,7 +122,7 @@ def MACD(series: pd.Series, lookback: int, fast: int, slow: int) -> pd.Series:
         fast period for the MACD
     slow : int
         slow period for the MACD
-        
+
     Returns
     -------
     pd.Series
@@ -128,13 +130,17 @@ def MACD(series: pd.Series, lookback: int, fast: int, slow: int) -> pd.Series:
     """
 
     # Calculate MACD line
-    macd = series.ewm(span=fast, adjust=False).mean() - series.ewm(span=slow, adjust=False).mean()
-    
+    macd = (
+        series.ewm(span=fast, adjust=False).mean()
+        - series.ewm(span=slow, adjust=False).mean()
+    )
+
     # Calculate Signal line from the MACD line
     signal = macd.ewm(span=lookback, adjust=False).mean()
-    
+
     return macd, signal
 
+
 def RSI(series: pd.Series, lookback: int) -> pd.Series:
     """
     Relative Strength Index
@@ -145,7 +151,7 @@ def RSI(series: pd.Series, lookback: int) -> pd.Series:
         time series to calculate the RSI for
     lookback : int
         lookback period for the RSI
-        
+
     Returns
     -------
     pd.Series
@@ -158,10 +164,9 @@ def RSI(series: pd.Series, lookback: int) -> pd.Series:
     # Separate gains and losses
     gain = (delta.where(delta > 0, 0)).rolling(window=lookback).mean()
     loss = (-delta.where(delta < 0, 0)).rolling(window=lookback).mean()
-    
+
     # Calculate the Relative Strength (RS)
     rs = gain / loss
-    
+
     # Calculate RSI
     return 100 - (100 / (1 + rs))
-    

{quantmod-0.0.4 → quantmod-0.0.5}/quantmod/markets/yahoo.py

@@ -46,32 +46,38 @@ from typing import Union, List
 #     # Ensure cache directory exists
 #     if not os.path.exists(CACHE_DIR):
 #         os.makedirs(CACHE_DIR)
-    
+
 #     cache_file = _get_cache_file_name(tickers, start_date, end_date, period, interval)
-    
+
 #     # Check if cached file exists
 #     if os.path.exists(cache_file):
 #         # print(f"Loading data from cache: {cache_file}")
 #         return joblib.load(cache_file)
-    
+
 #     try:
 #         # Download data from yfinance
 #         data = yf.download(tickers, start=start_date, end=end_date, auto_adjust=True, progress=False, period=period, interval=interval)
-        
+
 #         # Save data to cache
 #         joblib.dump(data, cache_file)
 #         # print(f"Data cached to: {cache_file}")
-    
+
 #     except Exception as e:
 #         print(f"Error downloading data: {e}")
 #         raise
-    
+
 #     return data
 
 
-def getData(tickers: Union[str, List[str]], start_date: str = None, end_date: str = None, period: str = '1mo', interval: str = '1d') -> pd.DataFrame:
+def getData(
+    tickers: Union[str, List[str]],
+    start_date: str = None,
+    end_date: str = None,
+    period: str = "1mo",
+    interval: str = "1d",
+) -> pd.DataFrame:
     """
-    Retrieve data from yfinance library for specified tickers.
+    Retrieve data using yfinance library for specified tickers.
 
     Parameters
     ----------
@@ -94,16 +100,25 @@ def getData(tickers: Union[str, List[str]], start_date: str = None, end_date: st
         DataFrame with OHLC[A]V (Open, High, Low, Close, Adj Close, Volume).
     """
 
-    cols = ['Open', 'High', 'Low', 'Close', 'Volume']
-    data = yf.download(tickers, start=None, end=None, auto_adjust=True, progress=False, multi_level_index=False, period=period, interval=interval)
-    
+    cols = ["Open", "High", "Low", "Close", "Volume"]
+    data = yf.download(
+        tickers,
+        start=start_date,
+        end=end_date,
+        auto_adjust=True,
+        progress=False,
+        multi_level_index=False,
+        period=period,
+        interval=interval,
+    )
+
     return data[cols]
 
 
-# Retrieve ticker object from yfinance library
+# Retrieve ticker object using yfinance library
 def getTicker(ticker: str) -> yf.Ticker:
     """
-    Retrieve ticker object from yfinance library.
+    Retrieve ticker object using yfinance library.
 
     Parameters
     ----------
@@ -118,7 +133,7 @@ def getTicker(ticker: str) -> yf.Ticker:
 
     # for all available options, refer yfinance
     # .info
-    # .history      
+    # .history
     # .actions
     # .dividends
     # .splits
@@ -138,7 +153,7 @@ def getTicker(ticker: str) -> yf.Ticker:
     # .earnings_dates
     # .isin
     # .options
-    #. option_chain('YYYY-MM-DD')
+    # . option_chain('YYYY-MM-DD')
     # .news
 
     return yf.Ticker(ticker)

{quantmod-0.0.4 → quantmod-0.0.5}/quantmod/models/__init__.py

@@ -19,10 +19,14 @@
 from .optioninputs import OptionInputs
 from .blackscholes import BlackScholesOptionPricing
 from .montecarlo import MonteCarloOptionPricing
+from .binomial import OptionType, ExerciseStyle, BinomialOptionPricing
 
 
 __all__ = [
     "OptionInputs",
-    "BlackScholesOptionPricing", 
+    "OptionType",
+    "ExerciseStyle",
+    "BlackScholesOptionPricing",
     "MonteCarloOptionPricing",
+    "BinomialOptionPricing",
 ]