quantmod 0.0.1__py3-none-any.whl

quantmod/datasets/__init__.py

@@ -0,0 +1,24 @@
+# Quantmod Python Package
+# https://kannansingaravelu.com/
+
+# Copyright 2024 Kannan Singaravelu
+
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+from .dataloader import load_historical_data
+
+
+__all__ = [
+    "load_historical_data",
+]

quantmod/datasets/dataloader.py

@@ -0,0 +1,61 @@
+import pandas as pd
+from quantmod.utils import convert_date_format
+
+def fetch_historical_data(symbol: str, start_date: str=None, end_date: str=None) -> pd.DataFrame:
+    """
+    Load historical data for a given symbol
+
+    Parameters
+    ----------
+    symbol : str
+        The symbol to load data for, either 'spx' or 'nifty'
+    start_date : str, optional
+        The start date to load data for, in 'yyyy-mm-dd' format, by default None
+    end_date : str, optional
+        The end date to load data for, in 'yyyy-mm-dd' format, by default None
+
+    Returns
+    -------
+    pd.DataFrame
+        The historical data for the given symbol
+
+    Raises
+    ------
+    ValueError
+        If the symbol is invalid or the start date is greater than the end date
+        If the start date is less than the first date in the dataset or the end date is greater than the last date in the dataset   
+        If the start date is greater than the last date in the dataset or the end date is less than the first date in the dataset
+    """
+
+    if symbol.lower() == "spx":    
+        df = pd.read_csv("./data/spx.csv")
+    elif symbol.lower() == "nifty":
+        df = pd.read_csv("./data/nifty50.csv")
+    else:
+        raise ValueError("Invalid symbol. Only SPX & NIFTY is supported")
+    
+    df = df.rename(columns=str.lower)
+    df = convert_date_format(df, 'date')
+
+    if start_date is None or end_date is None:
+        return df
+
+    elif start_date > end_date:
+        raise ValueError("Start date should be less than or equal to end date")
+    
+    elif start_date < df.date.iloc[0] or end_date < df.date.iloc[0]:
+        raise ValueError(f"Date should be greater than or equal to {df.date.iloc[0]}")
+    
+    elif start_date > df.date.iloc[-1] or end_date > df.date.iloc[-1]:
+        raise ValueError(f"Date should be less than or equal to {df.date.iloc[-1]}")
+    
+    else:
+        # Use query method for filtering based on date range
+        query_str = f"date >= '{start_date}' and date <= '{end_date}'"
+        return df.query(query_str)
+    
+
+# if __name__ == "__main__":
+#     df = fetch_historical_data("nifty")
+#     print(df.head())
+#     print(df.tail())

quantmod/derivatives/__init__.py

@@ -0,0 +1,23 @@
+# Quantmod Python Package
+# https://kannansingaravelu.com/
+
+# Copyright 2024 Kannan Singaravelu
+
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+from .options import maxpain
+
+__all__ = [
+    "maxpain",
+]

quantmod/derivatives/options.py

@@ -0,0 +1,47 @@
+# Maximum Pain Level
+def maxpain(strike: list, calloi: list, putoi: list) -> float:
+    """
+    Calculate option max pain for a given range of strike price, call and put open interest
+    Max pain is the (strike) price at which least amount of pain (money is lost) by
+    option writers, thereby causing maximum pain to option buyers. This level 
+    is assumed to be the price at which the market is most likely to expire on 
+    the (derivatives) contract mautiry date.
+
+    Parameters
+    ----------
+    strike : list
+        list of strike prices
+    calloi : list
+        list of call open interest
+    putoi : list
+        list of put open interst
+
+    Returns
+    -------
+    float
+        maximum pain strike level
+    """
+    
+    nrows = len(strike)
+    cvalue = [0]*nrows
+    pvalue = [0]*nrows
+    tvalue = [0]*nrows
+
+    for i in range(nrows-1, 0, -1):
+        csum = 0
+        for j in range(i):
+            csum = csum + (strike[i] - strike[j]) * calloi[j]
+            cvalue[i] = csum
+
+    for i in range(nrows-1):
+        psum = 0
+        for j in range(i+1,nrows,1):
+            psum = psum +  (strike[i] - strike[j]) * -1 * putoi[j]
+            pvalue[i] = psum
+
+    for i in range(nrows):
+        tvalue[i] = cvalue[i] + pvalue[i]
+
+    mp = min(tvalue)
+
+    return strike[tvalue.index(mp)]

quantmod/indicators/__init__.py

@@ -0,0 +1,23 @@
+# Quantmod Python Package
+# https://kannansingaravelu.com/
+
+# Copyright 2024 Kannan Singaravelu
+
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+from .indicators import ATR
+
+__all__ = [
+    "ATR",
+]

quantmod/indicators/indicators.py

@@ -0,0 +1,51 @@
+import pandas as pd
+
+def ATR(df: pd.DataFrame, lookback: int = 14) -> pd.Series:
+    """
+    Calculate the Average True Range (ATR).
+
+    ATR is a volatility indicator that measures the average of the true range values
+    over a specified period. An expanding ATR indicates increased volatility, while
+    a low ATR value indicates a series of periods with small price ranges.
+
+    Parameters
+    ----------
+    df : pd.DataFrame
+        DataFrame with OHLC (Open, High, Low, Close) price data.
+    lookback : int, optional
+        Number of periods to use for ATR calculation, by default 14.
+
+    Returns
+    -------
+    pd.Series
+        A pandas Series containing the ATR values for each period.
+
+    Examples
+    --------
+    >>> import pandas as pd
+    >>> df = pd.DataFrame({
+    ...     'Open': [10, 11, 12],
+    ...     'High': [12, 13, 14],
+    ...     'Low': [9, 10, 11],
+    ...     'Close': [11, 12, 13]
+    ... })
+    >>> atr = ATR(df, lookback=2)
+    >>> print(atr)
+    0         NaN
+    1    3.000000
+    2    2.750000
+    dtype: float64
+    """
+    
+    df = df.copy()
+    
+    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']

quantmod/main.py

@@ -0,0 +1,3 @@
+# main.py
+def hello():
+    print("Welcome to the world of Quant!")

quantmod/markets/__init__.py

@@ -0,0 +1,24 @@
+# Quantmod Python Package
+# https://kannansingaravelu.com/
+
+# Copyright 2024 Kannan Singaravelu
+
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+from .yahoo import getData, getTicker
+
+__all__ = [
+    "getData",
+    "getTicker",
+]

quantmod/markets/bb.py

@@ -0,0 +1,48 @@
+# current under testing / development
+
+import datetime
+import pandas as pd
+from openbb import obb
+from typing import List, Union, Optional, Literal
+
+
+def getData(symbol: Union[str, List[str]], 
+            start_date: Union[datetime.date, None, str]=None ,
+            end_date: Union[datetime.date, None, str]=None, 
+            provider: str = 'yfinance',
+            interval: str = '1d') -> pd.DataFrame:
+    """
+    Get historical price data for a given stock.
+
+    Parameters
+    ----------
+    symbol : Union[str, List[str]]
+        Symbol to get data for. Multiple comma separated items allowed for provider(s): fmp, polygon, tiingo, yfinance.
+    start_date : Union[date, None, str]
+        Start date of the data, in YYYY-MM-DD format.
+    end_date : Union[date, None, str]
+        End date of the data, in YYYY-MM-DD format.
+    provider : str, optional
+        The provider to use, by default 'yfinance'. If None, the priority list configured in the settings is used. Default priority: fmp, intrinio, polygon, tiingo, yfinance.
+    interval : str, optional
+        Time interval of the data to return. Default is '1d'.
+        valid intervals: 1m,2m,5m,15m,30m,60m,90m,1h,1d,5d,1W,1M,1Q
+
+    Returns
+    -------
+    pd.DataFrame
+        DataFrame with OHLC[A]V (Open, High, Low, Close, Adj Close, Volume).
+    """
+
+    output = obb.equity.price.historical(
+        symbol, 
+        start_date=start_date, 
+        end_date=end_date,
+        interval=interval
+    ).to_df()
+
+    return output.groupby('column')
+
+if __name__ == "__main__":
+    df = getData(["AAPL","SPY"], interval="1d")
+    print(df.head())

quantmod/markets/yahoo.py

@@ -0,0 +1,141 @@
+import pandas as pd
+import yfinance as yf
+import joblib
+import hashlib
+import os
+from typing import Union, List
+
+# # Directory to store cache files
+# CACHE_DIR = '.cache'
+
+# def _get_cache_file_name(tickers: Union[str, List[str]], start_date: str, end_date: str, period: str, interval: str) -> str:
+#     """
+#     Generate a cache file name based on the parameters.
+#     """
+#     if isinstance(tickers, str):
+#         tickers = [tickers]
+#     key = f"{','.join(tickers)}_{start_date}_{end_date}_{period}_{interval}"
+#     cache_key = hashlib.md5(key.encode()).hexdigest()
+#     return os.path.join(CACHE_DIR, f"{cache_key}.pkl")
+
+
+# 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, with caching.
+
+#     Parameters
+#     ----------
+#     tickers : str or list
+#         Symbol or list of symbols.
+#     start_date : str, optional
+#         Start date, by default None.
+#     end_date : str, optional
+#         End date, by default None.
+#     period : str, optional
+#         Period, by default '1mo'.
+#         Valid periods: 1d, 5d, 1mo, 3mo, 6mo, 1y, 2y, 5y, 10y, ytd, max.
+#     interval : str, optional
+#         Interval, by default '1d', max 60 days.
+#         Valid intervals: 1m, 2m, 5m, 15m, 30m, 60m, 90m, 1h, 1d, 5d, 1wk, 1mo, 3mo.
+
+#     Returns
+#     -------
+#     pd.DataFrame
+#         DataFrame with OHLC[A]V (Open, High, Low, Close, Adj Close, Volume).
+#     """
+#     # 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:
+    """
+    Retrieve data from yfinance library for specified tickers.
+
+    Parameters
+    ----------
+    tickers : str or list
+        symbol or list of symbols
+    start : str, optional
+        start date, by default None
+    end : str, optional
+        end date, by default None
+    period : str, optional
+        period, by default '1mo'
+        valid periods: 1d,5d,1mo,3mo,6mo,1y,2y,5y,10y,ytd,max
+    interval : str, optional
+        interval, by default '1d', max 60 days
+        valid intervals: 1m,2m,5m,15m,30m,60m,90m,1h,1d,5d,1wk,1mo,3mo
+
+    Returns
+    -------
+    pd.DataFrame
+        DataFrame with OHLC[A]V (Open, High, Low, Close, Adj Close, Volume).
+    """
+
+    return yf.download(tickers, start=None, end=None, auto_adjust=True, progress=False, period=period, interval=interval)
+
+
+# Retrieve ticker object from yfinance library
+def getTicker(ticker: str) -> yf.Ticker:
+    """
+    Retrieve ticker object from yfinance library.
+
+    Parameters
+    ----------
+    ticker : str
+        symbol
+
+    Returns
+    -------
+    yf.Ticker
+        Ticker object
+    """
+
+    # for all available options, refer yfinance
+    # .info
+    # .history      
+    # .actions
+    # .dividends
+    # .splits
+    # .financials
+    # .quarterly_financials
+    # .major_holders
+    # .institutional_holders
+    # .balance_sheet
+    # .quarterly_balance_sheet
+    # .cashflow
+    # .quarterly_cashflow
+    # .earnings
+    # .quarterly_earnings
+    # .sustainability
+    # .recommendations
+    # .calendar
+    # .earnings_dates
+    # .isin
+    # .options
+    #. option_chain('YYYY-MM-DD')
+    # .news
+
+    return yf.Ticker(ticker)

quantmod/models/__init__.py

@@ -0,0 +1,28 @@
+# Quantmod Python Package
+# https://kannansingaravelu.com/
+
+# Copyright 2024 Kannan Singaravelu
+
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+from .optioninputs import OptionInputs
+from .blackscholes import BlackScholesOptionPricing
+from .montecarlo import MonteCarloOptionPricing
+
+
+__all__ = [
+    "OptionInputs",
+    "BlackScholesOptionPricing", 
+    "MonteCarloOptionPricing",
+]

quantmod/models/blackscholes.py

@@ -0,0 +1,156 @@
+from pydantic import BaseModel, Field
+import numpy as np
+from scipy.stats import norm
+from scipy.optimize import brentq
+from typing import Tuple
+from .optioninputs import OptionInputs
+
+
+class BlackScholesOptionPricing:
+    """
+    Class for Black-Scholes Option Pricing
+
+    Parameters
+    ----------
+    inputs : OptionInputs
+        Option inputs parameters
+
+    Returns
+    -------
+    attributes: float
+        call_price, put_price
+
+        call_delta, put_delta 
+
+        gamma 
+        
+        vega
+        
+        call_theta, put_theta
+
+        call_rho, put_rho
+        
+        impvol
+    """
+    
+    def __init__(self, inputs: OptionInputs) -> None:
+        self.inputs = inputs
+        self._a_ = self.inputs.volatility * np.sqrt(self.inputs.ttm)
+        
+        self._d1_ = (np.log(self.inputs.spot / self.inputs.strike) +
+                     (self.inputs.rate + (self.inputs.volatility**2) / 2) * self.inputs.ttm) / self._a_
+        
+        self._d2_ = self._d1_ - self._a_
+        self._b_ = np.exp(-self.inputs.rate * self.inputs.ttm)
+        
+        self.call_price, self.put_price = self._price()
+        self.call_delta, self.put_delta = self._delta()
+        self.gamma = self._gamma()
+        self.vega = self._vega()
+        self.call_theta, self.put_theta = self._theta()
+        self.call_rho, self.put_rho = self._rho()
+        self.impvol = self._impvol()        
+
+    def _price(self) -> Tuple[float, float]:
+        """
+        Calculate option prices: Call price and Put price
+
+        Returns
+        -------
+        Tuple[float, float]
+            Call price and Put price
+        """
+        call = self.inputs.spot * norm.cdf(self._d1_) - self.inputs.strike * self._b_ * norm.cdf(self._d2_)
+        put = self.inputs.strike * self._b_ * norm.cdf(-self._d2_) - self.inputs.spot * norm.cdf(-self._d1_)
+        return call, put
+
+    def _delta(self) -> Tuple[float, float]:
+        """
+        Calculate option deltas: Call delta and Put delta
+
+        Returns
+        -------
+        Tuple[float, float]
+            Call delta and Put delta
+        """
+        call = norm.cdf(self._d1_)
+        put = -norm.cdf(-self._d1_)
+        return call, put
+
+    def _gamma(self) -> float:
+        """
+        Calculate option gamma
+
+        Returns
+        -------
+        float
+            Gamma
+        """
+        return norm.pdf(self._d1_) / (self.inputs.spot * self._a_)
+
+    def _vega(self) -> float:
+        """
+        Calculate option vega
+
+        Returns
+        -------
+        float
+            Vega
+        """
+        return self.inputs.spot * norm.pdf(self._d1_) * np.sqrt(self.inputs.ttm) / 100
+
+    def _theta(self) -> Tuple[float, float]:
+        """
+        Calculate option thetas: Call theta and Put theta
+
+        Returns
+        -------
+        Tuple[float, float]
+            Call theta and Put theta
+        """
+        call = -self.inputs.spot * norm.pdf(self._d1_) * self.inputs.volatility / (2 * np.sqrt(self.inputs.ttm)) - \
+               self.inputs.rate * self.inputs.strike * self._b_ * norm.cdf(self._d2_)
+
+        put = -self.inputs.spot * norm.pdf(self._d1_) * self.inputs.volatility / (2 * np.sqrt(self.inputs.ttm)) + \
+               self.inputs.rate * self.inputs.strike * self._b_ * norm.cdf(-self._d2_)
+        return call / 365, put / 365
+
+    def _rho(self) -> Tuple[float, float]:
+        """
+        Calculate option rhos: Call rho and Put rho
+
+        Returns
+        -------
+        Tuple[float, float]
+            Call rho and Put rho
+        """
+        call = self.inputs.strike * self.inputs.ttm * self._b_ * norm.cdf(self._d2_) / 100
+        put = -self.inputs.strike * self.inputs.ttm * self._b_ * norm.cdf(-self._d2_) / 100
+        return call, put
+    
+    def _impvol(self) -> float:
+        """
+        Calculate option implied volatility
+
+        Returns
+        -------
+        float
+            Implied volatility
+        """
+        if self.inputs.callprice is None and self.inputs.putprice is None:
+            return self.inputs.volatility
+        else:
+            def f(sigma: float) -> float:
+                option = BlackScholesOptionPricing(OptionInputs(spot=self.inputs.spot, strike=self.inputs.strike, rate=self.inputs.rate, ttm=self.inputs.ttm, volatility=sigma))
+                if self.inputs.callprice is not None:
+                     model_call_price = option.call_price 
+                     return model_call_price  - self.inputs.callprice 
+                else:
+                    model_put_price = option.put_price
+                    return model_put_price - self.inputs.putprice
+            try:
+                implied_vol = brentq(f, a=1e-5, b=5.0, xtol=1e-8, rtol=1e-8, maxiter=100)
+                implied_vol = max(implied_vol, 1e-5)
+            except ValueError:
+                implied_vol = np.nan
+            return implied_vol