quantmod 0.0.1__py3-none-any.whl

quantmod/models/montecarlo.py

@@ -0,0 +1,115 @@
+import numpy as np
+from pydantic import BaseModel, Field
+from typing import Optional,Tuple
+from .optioninputs import OptionInputs
+
+# Monte Carlo Option Pricing Engine
+class MonteCarloOptionPricing:
+    """
+    Class for Monte Carlo Option Pricing
+
+    Parameters
+    ----------
+    inputs : OptionInputs
+        Option inputs parameters
+    initialspot : float, optional
+        Initial stock price
+    nsims : int, optional
+        Number of simulations
+    timestep : int, optional
+        Timestep, by default 252
+    barrier : float, optional
+        Barrier, by default None
+    rebate : int, optional
+        Rebate, by default None
+
+    Returns
+    -------
+    attributes: float
+        call_vanilla, put_vanilla
+
+        call_asian, put_asian
+
+        upandoutcall
+    """
+    
+    def __init__(self, 
+                 inputs: OptionInputs, 
+                 initialspot: float = Field(..., gt=0, description="Initial stock price"), 
+                 nsims: int = Field(..., gt=0, description="Number of simulations"), 
+                 timestep: int = 252, 
+                 barrier: Optional[float] = None, 
+                 rebate: Optional[int] = None
+                 ) -> None:
+        
+        self.inputs = inputs
+        self.initialspot = initialspot
+        self.nsims = nsims
+        self.timestep = timestep
+        self.barrier = barrier
+        self.rebate = rebate
+
+        self.call_vanilla, self.put_vanilla = self._vanillaoption()
+        self.call_asian, self.put_asian = self._asianoption()
+        self.upandoutcall = self._upandoutcall()
+
+    @property
+    def _discount_factor(self) -> float:
+        return np.exp(-self.inputs.rate * self.inputs.ttm)
+
+    @property
+    def _pseudorandomnumber(self) -> np.ndarray:
+        return np.random.standard_normal(self.nsims)
+
+    @property
+    def _simulatepath(self) -> np.ndarray:
+        """Simulate price path"""
+        np.random.seed(2024)
+
+        dt = self.inputs.ttm / self.timestep
+
+        S = np.zeros((self.timestep, self.nsims))
+        S[0] = self.initialspot
+
+        for i in range(0, self.timestep-1):
+            w = self._pseudorandomnumber
+            S[i+1] = S[i] * (1 + self.inputs.rate*dt + self.inputs.volatility*np.sqrt(dt)*w)
+
+        return S
+
+    def _vanillaoption(self) -> Tuple[float, float]:
+        """Calculate vanilla option payoff"""
+        S = self._simulatepath
+
+        vanilla_call = self._discount_factor * np.mean(np.maximum(0, S[-1] -  self.inputs.strike))
+        vanilla_put = self._discount_factor * np.mean(np.maximum(0,  self.inputs.strike - S[-1]))
+
+        return [vanilla_call, vanilla_put]
+
+    def _asianoption(self) -> Tuple[float]:
+        """Calculate asian option payoff"""
+        S = self._simulatepath
+
+        A = S.mean(axis=0)
+
+        asian_call = self._discount_factor * np.mean(np.maximum(0, A -  self.inputs.strike))
+        asian_put = self._discount_factor * np.mean(np.maximum(0,  self.inputs.strike - A))
+
+        return [asian_call, asian_put]
+
+    def _upandoutcall(self) ->  float:
+        """Calculate up-and-out barrier call option payoff"""
+        S = self._simulatepath
+
+        # Barrier shift
+        barriershift = self.barrier * np.exp(0.5826 * self.inputs.volatility * np.sqrt(self.inputs.ttm/self.timestep))
+
+        value = 0
+        for i in range(self.nsims):
+            if S[:,i].max () < barriershift:
+                value += np.maximum(0, S[-1,i] -  self.inputs.strike)
+            else:
+                value += self.rebate
+
+        return self._discount_factor * value / self.nsims
+    

quantmod/models/optioninputs.py

@@ -0,0 +1,44 @@
+from pydantic import BaseModel, Field
+from typing import Optional
+
+class OptionInputs(BaseModel):
+    """
+    Option inputs parameters
+
+    Parameters
+    ----------
+    spot : float
+        Spot price of the underlying asset
+    strike : float
+        Strike price of the option
+    rate : float
+        Risk-free interest rate
+    ttm : float
+        Time to maturity in years
+    volatility : float
+        Volatility of the underlying asset
+    callprice : float | None
+        Default is None
+        Market price of the call option
+    putprice : float | None
+        Default is None
+        Market price of the put option
+    
+    Returns
+    -------
+    OptionInputs
+        Option inputs parameters
+    
+    Raises
+    ------
+    ValueError
+        If any of the input parameters are invalid
+    """
+
+    spot: float = Field(..., gt=0, description="Spot price of the underlying asset")
+    strike: float = Field(..., gt=0, description="Strike price of the option")
+    rate: float = Field(..., gt=0, le=1, description="Risk-free interest rate")
+    ttm: float = Field(..., gt=0, description="Time to maturity in years")
+    volatility: float = Field(..., gt=0, description="Volatility of the underlying asset")
+    callprice: Optional[float] = Field(default=None, ge=0, description="Market price of the call option")
+    putprice: Optional[float] = Field(default=None, ge=0, description="Market price of the put option")

quantmod/risk/__init__.py

@@ -0,0 +1,27 @@
+# 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 .riskinputs import RiskInputs
+from .var import ValueAtRisk, ConditionalVaR
+from .varbacktester import VarBacktester
+
+__all__ = [
+    "RiskInputs",
+    "ValueAtRisk",
+    "ConditionalVaR",
+    "VarBacktester",
+]

quantmod/risk/riskinputs.py

@@ -0,0 +1,36 @@
+from pydantic import BaseModel, Field, field_validator
+from typing import List
+
+class RiskInputs(BaseModel):
+    """
+    RiskInputs parameters
+
+    Parameters
+    ----------
+    returns : List[float]
+        List of historical returns
+    confidence_level : float
+        The confidence level for the VaR calculation
+
+    Returns
+    -------
+    RiskInputs
+        RiskInputs parameters
+
+    Raises
+    ------
+    ValueError
+        If any of the input parameters are invalid
+
+    """
+    returns: List[float] = Field(..., description="List of historical returns")
+    confidence_level: float = Field(..., ge=0.0, le=1.0, description="The confidence level for the VaR calculation")
+
+    class Config:
+        arbitrary_types_allowed = True
+
+@field_validator('returns')
+def check_returns(cls, v):
+    if len(v) <= 252: # Assuming at least one year of daily data
+        raise ValueError("At least 252 returns are required for meaningful backtest")
+    return v

quantmod/risk/var.py

@@ -0,0 +1,103 @@
+import pandas as pd
+import numpy as np
+from scipy import stats
+from arch import arch_model
+from .riskinputs import RiskInputs
+from typing import Literal
+
+
+class ValueAtRisk:
+    """
+    Class to calculate Value at Risk (VaR) based on returns and confidence level
+
+    Parameters
+    ----------
+    inputs : RiskInputs
+        An instance of Risk inputs containing returns and confidence level
+    method : Literal['historical', 'parametric', 'montecarlo']
+        The method to calculate VaR, by default 'historical'
+
+    Returns
+    -------
+    attributes: float
+        var
+    """
+
+    def __init__(self, inputs: RiskInputs, method: Literal['historical', 'parametric', 'montecarlo']) -> float:
+        self.inputs = inputs
+        self.returns = pd.Series(inputs.returns)
+        self.method = method
+        self.mean = np.mean(self.returns)
+        self.std = np.std(self.returns)
+        self.var = self._var()
+        
+    def _pvar(self) -> float:
+        """
+        Calculate the Value at Risk (VaR) at the specified confidence level using variance - covariance approach
+        """
+        # return (self.mean + stats.norm.ppf(1-self.inputs.confidence_level) * self.std)
+        return np.round(stats.norm.ppf(1-self.inputs.confidence_level, self.mean, self.std),4)
+
+    def _hvar(self) -> float:
+        """
+        Calculate the Value at Risk (VaR) at the specified confidence level using historical returns
+        """
+        return np.round(np.percentile(self.returns, (1 - self.inputs.confidence_level) * 100),4)
+
+    def _mcvar(self) -> float:
+        """
+        Calculate the Value at Risk (VaR) at the specified confidence level using Monte Carlo simulation
+        """
+        simulated_returns = stats.norm.rvs(loc=self.mean, scale=self.std, size=5000)
+        return np.round(np.percentile(simulated_returns, (1 - self.inputs.confidence_level) * 100),4)
+
+    # def _garchvar(self) -> float:
+    #     """
+    #     Calculate the Value at Risk (VaR) at the specified confidence level using GARCH model
+    #     """
+    #     model = arch_model(self.returns*1000, vol='GARCH', p=1, q=1, dist="gaussian")
+    #     fitted_model = model.fit(disp="off")
+    #     conditional_volatilities = fitted_model.conditional_volatility
+    #     return (stats.norm.ppf(1-self.inputs.confidence_level) * conditional_volatilities.iloc[-1]) / 1000
+
+
+    def _var(self) -> float:
+        if self.method == 'parametric':
+            return self._pvar()
+        elif self.method == 'historical':
+            return self._hvar()
+        elif self.method == 'montecarlo':
+            return self._mcvar()
+        # elif self.method == 'garch':
+        #     return self._garchvar()
+        else:
+            raise ValueError("Invalid method")
+
+
+class ConditionalVaR:
+    """
+    Class to calculate Conditional Value at Risk (CVaR) aka Expected Shortfall (ES) based on historical returns and confidence level
+
+    Parameters
+    ----------
+    inputs : RiskInputs
+        An instance of Risk inputs containing returns and confidence level
+
+    Returns
+    -------
+    attributes: float
+        CVaR
+    """
+
+    def __init__(self, inputs: RiskInputs) -> float:       
+        self.inputs = inputs
+        self.returns = pd.Series(inputs.returns)
+        self.cvar = self._cvar()
+
+    def _cvar(self) -> float:
+        """
+        Calculate the Conditional Value at Risk (CVaR) at the specified confidence level
+        """
+        var = np.percentile(self.returns, (1 - self.inputs.confidence_level) * 100)
+        tail_returns = self.returns[self.returns <= var]
+        return np.round(tail_returns.mean() if len(tail_returns) > 0 else float('nan'),4)

quantmod/risk/varbacktester.py

@@ -0,0 +1,85 @@
+import pandas as pd
+import numpy as np
+from scipy import stats
+from tabulate import tabulate
+from .riskinputs import RiskInputs
+
+
+class VarBacktester:
+    """
+    Class to perform a backtest for Value at Risk (VaR) calculations with non-overlapping windows  
+
+    Parameters
+    ----------
+    inputs : RiskInputs
+        An instance of Risk inputs containing returns and confidence level
+    window_volatility : int, optional
+        The window size for the rolling volatility calculation, by default 21
+    window_forward : int, optional
+        The window size for the rolling forward calculation, by default 10
+
+    Returns
+    -------
+    attributes: tabular output
+        run
+    """ 
+
+    def __init__(self, inputs: RiskInputs, window_volatility:int = 21, window_forward: int = 10) -> pd.DataFrame:
+        self.inputs = inputs
+        self.returns = pd.Series(inputs.returns)
+        self.window_volatility = window_volatility
+        self.window_forward = window_forward
+        self.run = self._runbacktest()
+        
+               
+    def _runbacktest(self) -> str:
+        """
+        Perform VaR backtest with non-overlapping windows
+
+        Returns
+        -------
+        str
+           A tabular output containing the results of the backtest
+        """
+        # Create a dataframe with returns
+        data = pd.DataFrame({'returns': self.returns})
+
+        # Calculate rolling VaR
+        data['VaR'] = data['returns'].rolling(self.window_volatility).std()*np.sqrt(self.window_forward)*stats.norm.ppf(1-self.inputs.confidence_level)
+        
+        # Calculate forward returns
+        data['shifted_returns'] = data['returns'].shift(-2) # non overlapping window
+        data['forward_returns'] = data['shifted_returns'].rolling(window=self.window_forward).sum()
+        data['shifted_forward_returns'] = data['forward_returns'].shift(-self.window_forward+1)
+        
+        # Identify breaches
+        data['breach'] = data['shifted_forward_returns'] < data['VaR']
+
+        # Calculate number and percentage of breaches
+        total_breaches = data['breach'].sum()
+        total_observations = len(data) - self.window_volatility - self.window_forward 
+        percentage_breaches = (total_breaches / total_observations) * 100 if total_observations > 0 else np.nan
+
+        # Calculate continuous breaches
+        data['breach_shift'] = data['breach'].shift(1)
+        data['continuous_breaches'] = (data['breach'] & (data['breach'] == data['breach_shift'])).astype(int)
+        number_continuous_breaches = data['continuous_breaches'].sum()
+
+        # # Print data of breaches
+        # print(data[data['breach']])
+
+        # Conditional probability of breaches
+        non_nan_breaches = data['breach'].dropna()
+        conditional_probability = non_nan_breaches.mean() if len(non_nan_breaches) > 0 else np.nan
+
+        # Ouput results in tabular format
+        header = ['Backtest Results', 'Values']
+        table = [
+            ['Actual Breaches', total_breaches],
+            ['Percentage of Actual Breaches', percentage_breaches],
+            ['Expected Breaches', int(total_observations*(1-self.inputs.confidence_level))],
+            ['Percentage of Expected Breaches', (1-self.inputs.confidence_level)*100],
+            ['Number of Continuous Breaches', number_continuous_breaches],
+            ['Conditional Probability of Breaches', conditional_probability*100]] 
+
+        return tabulate(table,headers=header, floatfmt=(".2f"))

quantmod/timeseries/__init__.py

@@ -0,0 +1,93 @@
+# 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 .timeseries import (
+    seriesHi, 
+    seriesLo, 
+    Op, 
+    Hi, 
+    Lo, 
+    Cl, 
+    Vo, 
+    Ad, 
+    OpCl, 
+    OpHi, 
+    OpLo, 
+    HiCl, 
+    HiLo, 
+    LoCl, 
+    Gap, 
+    lag, 
+    lead, 
+    last, 
+    first, 
+    trend_score,
+)
+
+
+from .performance import (
+    periodReturn, 
+    dailyReturn, 
+    weeklyReturn, 
+    monthlyReturn, 
+    quarterlyReturn, 
+    annualReturn, 
+    allReturn, 
+    cagr, 
+    volatility, 
+    sharpe, 
+    maxdd, 
+    calmar
+)
+
+
+__all__ = [
+    "seriesHi",
+    "seriesLo",
+    "Op",
+    "Hi",
+    "Lo",
+    "Cl",
+    "Vo",
+    "Ad",
+    "OpCl",
+    "OpHi",
+    "OpLo",
+    "HiCl",
+    "HiLo",
+    "LoCl",
+    "Gap",
+    "lag",
+    "lead",
+    "last",
+    "first",
+    "trend_score",
+    "periodReturn",
+    "dailyReturn",
+    "weeklyReturn",
+    "monthlyReturn",
+    "quarterlyReturn",
+    "annualReturn",
+    "allReturn",
+    "cagr",
+    "volatility",
+    "sharpe",
+    "maxdd",
+    "calmar",
+]