openseries 1.2.2__py3-none-any.whl → 1.2.4__py3-none-any.whl

openseries/simulation.py

@@ -1,6 +1,5 @@
 """
-Defining the ReturnSimulation class which simulates returns based on
-stochastic processes, and defining ModelParameters used by it.
+Defining the ReturnSimulation class and ModelParameters used by it.
 
 Source:
 http://www.turingfinance.com/random-walks-down-wall-street-stochastic-processes-in-python/
@@ -14,20 +13,26 @@ Processes that can be simulated in this module are:
 - Cox Ingersoll Ross
 - Ornstein Uhlenbeck
 """
+from __future__ import annotations
+
 import datetime as dt
-from math import log, pow as mathpow
-from typing import cast, Optional, Type, TypeVar
+from math import log
+from math import pow as mathpow
+from typing import Optional, TypeVar, cast
+
 from numpy import (
     add,
     array,
     exp,
     float64,
     insert,
-    random as nprandom,
     sqrt,
 )
+from numpy import (
+    random as nprandom,
+)
 from numpy.typing import NDArray
-from pandas import concat, DataFrame
+from pandas import DataFrame, concat
 from pydantic import BaseModel, ConfigDict
 
 from openseries.datefixer import generate_calender_date_range
@@ -36,16 +41,18 @@ from openseries.types import (
     DaysInYearType,
     SimCountType,
     TradingDaysType,
-    VolatilityType,
     ValueType,
+    VolatilityType,
 )
 
 TypeModelParameters = TypeVar("TypeModelParameters", bound="ModelParameters")
 TypeReturnSimulation = TypeVar("TypeReturnSimulation", bound="ReturnSimulation")
 
 
-class ReturnSimulation(BaseModel):
-    """Object of the class ReturnSimulation.
+class ReturnSimulation(BaseModel):  # type: ignore[misc]
+
+    """
+    Object of the class ReturnSimulation.
 
     Parameters
     ----------
@@ -75,6 +82,8 @@ class ReturnSimulation(BaseModel):
     @property
     def results(self: TypeReturnSimulation) -> DataFrame:
         """
+        Simulation data.
+
         Returns
         -------
         pandas.DataFrame
@@ -85,12 +94,13 @@ class ReturnSimulation(BaseModel):
     @property
     def realized_mean_return(self: TypeReturnSimulation) -> float:
         """
+        Annualized arithmetic mean of returns.
+
         Returns
         -------
         float
             Annualized arithmetic mean of returns
         """
-
         return cast(
             float,
             (self.results.pct_change().mean() * self.trading_days_in_year).iloc[0],
@@ -99,12 +109,13 @@ class ReturnSimulation(BaseModel):
     @property
     def realized_vol(self: TypeReturnSimulation) -> float:
         """
+        Annualized volatility.
+
         Returns
         -------
         float
             Annualized volatility
         """
-
         return cast(
             float,
             (self.results.pct_change().std() * sqrt(self.trading_days_in_year)).iloc[
@@ -114,11 +125,14 @@ class ReturnSimulation(BaseModel):
 
     @classmethod
     def convert_to_prices(
-        cls: Type[TypeReturnSimulation],
+        cls: type[TypeReturnSimulation],
         param: TypeModelParameters,
         log_returns: NDArray[float64],
     ) -> NDArray[float64]:
-        """Converts a sequence of log returns into normal returns (exponentiation)
+        """
+        Price series.
+
+        Converts a sequence of log returns into normal returns (exponentiation)
         and then computes a price sequence given a starting price, param.all_s0.
 
         Parameters
@@ -133,7 +147,6 @@ class ReturnSimulation(BaseModel):
         numpy.NDArray[float64]
             Price series
         """
-
         returns = exp(log_returns)
         # A sequence of prices starting with param.all_s0
         price_sequence: list[float] = [param.all_s0]
@@ -144,13 +157,16 @@ class ReturnSimulation(BaseModel):
 
     @classmethod
     def brownian_motion_log_returns(
-        cls: Type[TypeReturnSimulation],
+        cls: type[TypeReturnSimulation],
         param: TypeModelParameters,
         seed: Optional[int] = None,
     ) -> NDArray[float64]:
-        """This method returns a Wiener process. The Wiener process is also called
+        """
+        Brownian Motion log returns.
+
+        Method returns a Wiener process. The Wiener process is also called
         Brownian motion. For more information about the Wiener process check out
-        the Wikipedia page: http://en.wikipedia.org/wiki/Wiener_process
+        the Wikipedia page: http://en.wikipedia.org/wiki/Wiener_process.
 
         Parameters
         ----------
@@ -164,22 +180,22 @@ class ReturnSimulation(BaseModel):
         numpy.NDArray[float64]
             Brownian Motion log returns
         """
-
         if seed is not None:
             nprandom.seed(seed)
 
         sqrt_delta_sigma = sqrt(param.all_delta) * param.all_sigma
         return array(
-            nprandom.normal(loc=0, scale=sqrt_delta_sigma, size=param.all_time)
+            nprandom.normal(loc=0, scale=sqrt_delta_sigma, size=param.all_time),
         )
 
     @classmethod
     def brownian_motion_levels(
-        cls: Type[TypeReturnSimulation],
+        cls: type[TypeReturnSimulation],
         param: TypeModelParameters,
         seed: Optional[int] = None,
     ) -> NDArray[float64]:
-        """Delivers a price sequence whose returns evolve as to a brownian motion
+        """
+        Delivers a price sequence whose returns evolve as to a brownian motion.
 
         Parameters
         ----------
@@ -193,21 +209,24 @@ class ReturnSimulation(BaseModel):
         numpy.NDArray[float64]
             Price sequence which follows a brownian motion
         """
-
         return cls.convert_to_prices(
-            param, cls.brownian_motion_log_returns(param, seed=seed)
+            param,
+            cls.brownian_motion_log_returns(param, seed=seed),
         )
 
     @classmethod
     def geometric_brownian_motion_log_returns(
-        cls: Type[TypeReturnSimulation],
+        cls: type[TypeReturnSimulation],
         param: TypeModelParameters,
         seed: Optional[int] = None,
     ) -> NDArray[float64]:
-        """This method constructs a sequence of log returns which, when
+        """
+        Log returns of a Geometric Brownian Motion process.
+
+        Method constructs a sequence of log returns which, when
         exponentiated, produce a random Geometric Brownian Motion (GBM).
         GBM is the stochastic process underlying the Black Scholes
-        options pricing formula
+        options pricing formula.
 
         Parameters
         ----------
@@ -221,7 +240,6 @@ class ReturnSimulation(BaseModel):
         numpy.NDArray[float64]
             Log returns of a Geometric Brownian Motion process
         """
-
         wiener_process = array(cls.brownian_motion_log_returns(param, seed=seed))
         sigma_pow_mu_delta = (
             param.gbm_mu - 0.5 * mathpow(param.all_sigma, 2.0)
@@ -230,11 +248,12 @@ class ReturnSimulation(BaseModel):
 
     @classmethod
     def geometric_brownian_motion_levels(
-        cls: Type[TypeReturnSimulation],
+        cls: type[TypeReturnSimulation],
         param: TypeModelParameters,
         seed: Optional[int] = None,
     ) -> NDArray[float64]:
-        """Prices for an asset which evolves according to a geometric brownian motion
+        """
+        Prices for an asset which evolves according to a geometric brownian motion.
 
         Parameters
         ----------
@@ -248,20 +267,23 @@ class ReturnSimulation(BaseModel):
         numpy.NDArray[float64]
             Price levels for the asset
         """
-
         return cls.convert_to_prices(
-            param, cls.geometric_brownian_motion_log_returns(param, seed=seed)
+            param,
+            cls.geometric_brownian_motion_log_returns(param, seed=seed),
         )
 
     @classmethod
     def jump_diffusion_process(
-        cls: Type[TypeReturnSimulation],
+        cls: type[TypeReturnSimulation],
         param: TypeModelParameters,
         seed: Optional[int] = None,
     ) -> NDArray[float64]:
-        """This method produces a sequence of Jump Sizes which represent a jump
+        """
+        Jump sizes for each point in time (mostly zeroes if jumps are infrequent).
+
+        Method produces a sequence of Jump Sizes which represent a jump
         diffusion process. These jumps are combined with a geometric brownian
-        motion (log returns) to produce the Merton model
+        motion (log returns) to produce the Merton model.
 
         Parameters
         ----------
@@ -275,7 +297,6 @@ class ReturnSimulation(BaseModel):
         numpy.NDArray[float64]
             Jump sizes for each point in time (mostly zeroes if jumps are infrequent)
         """
-
         if seed is not None:
             nprandom.seed(seed)
         s_n = 0.0
@@ -299,13 +320,16 @@ class ReturnSimulation(BaseModel):
 
     @classmethod
     def geometric_brownian_motion_jump_diffusion_log_returns(
-        cls: Type[TypeReturnSimulation],
+        cls: type[TypeReturnSimulation],
         param: TypeModelParameters,
         seed: Optional[int] = None,
     ) -> NDArray[float64]:
-        """This method constructs combines a geometric brownian motion process
+        """
+        Geometric Brownian Motion process with jumps in it.
+
+        Method constructs combines a geometric brownian motion process
         (log returns) with a jump diffusion process (log returns) to produce a
-        sequence of gbm jump returns
+        sequence of gbm jump returns.
 
         Parameters
         ----------
@@ -319,21 +343,24 @@ class ReturnSimulation(BaseModel):
         numpy.NDArray[float64]
             Geometric Brownian Motion process with jumps in it
         """
-
         jump_diffusion = cls.jump_diffusion_process(param, seed=seed)
         geometric_brownian_motion = cls.geometric_brownian_motion_log_returns(
-            param, seed=seed
+            param,
+            seed=seed,
         )
         return add(jump_diffusion, geometric_brownian_motion)
 
     @classmethod
     def geometric_brownian_motion_jump_diffusion_levels(
-        cls: Type[TypeReturnSimulation],
+        cls: type[TypeReturnSimulation],
         param: TypeModelParameters,
         seed: Optional[int] = None,
     ) -> NDArray[float64]:
-        """Converts returns generated with a Geometric Brownian Motion process
-        with jumps into prices
+        """
+        Geometric Brownian Motion generated prices.
+
+        Converts returns generated with a Geometric Brownian Motion process
+        with jumps into prices.
 
         Parameters
         ----------
@@ -347,7 +374,6 @@ class ReturnSimulation(BaseModel):
         numpy.NDArray[float64]
             Geometric Brownian Motion generated prices
         """
-
         return cls.convert_to_prices(
             param,
             cls.geometric_brownian_motion_jump_diffusion_log_returns(param, seed=seed),
@@ -355,14 +381,17 @@ class ReturnSimulation(BaseModel):
 
     @classmethod
     def heston_construct_correlated_path(
-        cls: Type[TypeReturnSimulation],
+        cls: type[TypeReturnSimulation],
         param: TypeModelParameters,
         brownian_motion_one: NDArray[float64],
         seed: Optional[int] = None,
     ) -> tuple[NDArray[float64], NDArray[float64]]:
-        """This method is a simplified version of the Cholesky decomposition method for
+        """
+        Generate correlated Brownian Motion path.
+
+        Method is a simplified version of the Cholesky decomposition method for
         just two assets. It does not make use of matrix algebra and is therefore quite
-        easy to implement
+        easy to implement.
 
         Parameters
         ----------
@@ -378,33 +407,36 @@ class ReturnSimulation(BaseModel):
         tuple[NDArray[float64], NDArray[float64]]
             A correlated Brownian Motion path
         """
-
         if seed is not None:
             nprandom.seed(seed)
-        # We do not multiply by sigma here, we do that in the Heston model
+
         sqrt_delta = sqrt(param.all_delta)
-        # Construct a path correlated to the first path
+
         brownian_motion_two = []
         for npath in range(param.all_time - 1):
             term_one = param.cir_rho * brownian_motion_one[npath]
             term_two = sqrt(1 - mathpow(param.cir_rho, 2.0)) * nprandom.normal(
-                0, sqrt_delta
+                0,
+                sqrt_delta,
             )
             brownian_motion_two.append(term_one + term_two)
         return array(brownian_motion_one), array(brownian_motion_two)
 
     @classmethod
     def cox_ingersoll_ross_heston(
-        cls: Type[TypeReturnSimulation],
+        cls: type[TypeReturnSimulation],
         param: TypeModelParameters,
         seed: Optional[int] = None,
     ) -> tuple[NDArray[float64], NDArray[float64]]:
-        """This method returns the rate levels of a mean-reverting Cox Ingersoll Ross
+        """
+        Generate interest rate levels for the CIR process.
+
+        Method returns the rate levels of a mean-reverting Cox Ingersoll Ross
         process. It is used to model interest rates as well as stochastic
         volatility in the Heston model. Because the returns between the underlying
         and the stochastic volatility should be correlated we pass a correlated
         Brownian motion process into the method from which the interest rate levels
-        are constructed. The other correlated process is used in the Heston model
+        are constructed. The other correlated process is used in the Heston model.
 
         Parameters
         ----------
@@ -418,14 +450,15 @@ class ReturnSimulation(BaseModel):
         tuple[NDArray[float64], NDArray[float64]]
             The interest rate levels for the CIR process
         """
-
         if seed is not None:
             nprandom.seed(seed)
 
-        # We don't multiply by sigma here because we do that in heston
         sqrt_delta_sigma = sqrt(param.all_delta) * param.all_sigma
+
         brownian_motion_volatility = nprandom.normal(
-            loc=0, scale=sqrt_delta_sigma, size=param.all_time
+            loc=0,
+            scale=sqrt_delta_sigma,
+            size=param.all_time,
         )
         meanrev_vol, avg_vol, start_vol = (
             param.heston_a,
@@ -444,18 +477,21 @@ class ReturnSimulation(BaseModel):
 
     @classmethod
     def heston_model_levels(
-        cls: Type[TypeReturnSimulation],
+        cls: type[TypeReturnSimulation],
         param: TypeModelParameters,
         seed: Optional[int] = None,
     ) -> tuple[NDArray[float64], NDArray[float64]]:
-        """The Heston model is the geometric brownian motion model with stochastic
+        """
+        Generate prices for an asset following a Heston process.
+
+        The Heston model is the geometric brownian motion model with stochastic
         volatility. This stochastic volatility is given by the Cox Ingersoll Ross
         process. Step one on this method is to construct two correlated
         GBM processes. One is used for the underlying asset prices and the other
         is used for the stochastic volatility levels
         Get two correlated brownian motion sequences for the volatility parameter
         and the underlying asset brownian_motion_market,
-        brownian_motion_vol = get_correlated_paths_simple(param)
+        brownian_motion_vol = get_correlated_paths_simple(param).
 
         Parameters
         ----------
@@ -469,10 +505,11 @@ class ReturnSimulation(BaseModel):
         tuple[NDArray[float64], NDArray[float64]]
             The prices for an asset following a Heston process
         """
-
         brownian, cir_process = cls.cox_ingersoll_ross_heston(param, seed=seed)
         brownian, brownian_motion_market = cls.heston_construct_correlated_path(
-            param, brownian, seed=seed
+            param,
+            brownian,
+            seed=seed,
         )
 
         heston_market_price_levels: list[float] = [param.all_s0]
@@ -486,22 +523,25 @@ class ReturnSimulation(BaseModel):
                 * brownian_motion_market[hpath - 1]
             )
             heston_market_price_levels.append(
-                heston_market_price_levels[hpath - 1] + drift + vol
+                heston_market_price_levels[hpath - 1] + drift + vol,
             )
         return array(heston_market_price_levels), array(cir_process)
 
     @classmethod
     def cox_ingersoll_ross_levels(
-        cls: Type[TypeReturnSimulation],
+        cls: type[TypeReturnSimulation],
         param: TypeModelParameters,
         seed: Optional[int] = None,
     ) -> NDArray[float64]:
-        """This method returns the rate levels of a mean-reverting Cox Ingersoll Ross
+        """
+        Generate interest rate levels for the CIR process.
+
+        Method returns the rate levels of a mean-reverting Cox Ingersoll Ross (CIR)
         process. It is used to model interest rates as well as stochastic
         volatility in the Heston model. Because the returns between the underlying
         and the stochastic volatility should be correlated we pass a correlated
         Brownian motion process into the method from which the interest rate levels
-        are constructed. The other correlated process is used in the Heston model
+        are constructed. The other correlated process is used in the Heston model.
 
         Parameters
         ----------
@@ -515,7 +555,6 @@ class ReturnSimulation(BaseModel):
         numpy.NDArray[float64]
             The interest rate levels for the CIR process
         """
-
         brownian_motion = cls.brownian_motion_log_returns(param, seed=seed)
 
         levels: list[float] = [param.all_r0]
@@ -527,12 +566,12 @@ class ReturnSimulation(BaseModel):
 
     @classmethod
     def ornstein_uhlenbeck_levels(
-        cls: Type[TypeReturnSimulation],
+        cls: type[TypeReturnSimulation],
         param: TypeModelParameters,
         seed: Optional[int] = None,
     ) -> NDArray[float64]:
-        """This method returns the rate levels of a mean-reverting
-        Ornstein Uhlenbeck process
+        """
+        Generate rate levels of a mean-reverting Ornstein Uhlenbeck process.
 
         Parameters
         ----------
@@ -546,7 +585,6 @@ class ReturnSimulation(BaseModel):
         numpy.NDArray[float64]
             The interest rate levels for the Ornstein Uhlenbeck process
         """
-
         ou_levels: list[float] = [param.all_r0]
         brownian_motion_returns = cls.brownian_motion_log_returns(param, seed=seed)
         for hpath in range(1, param.all_time):
@@ -557,7 +595,7 @@ class ReturnSimulation(BaseModel):
 
     @classmethod
     def from_normal(
-        cls: Type[TypeReturnSimulation],
+        cls: type[TypeReturnSimulation],
         number_of_sims: SimCountType,
         mean_annual_return: float,
         mean_annual_vol: VolatilityType,
@@ -565,7 +603,8 @@ class ReturnSimulation(BaseModel):
         trading_days_in_year: DaysInYearType = 252,
         seed: Optional[int] = 71,
     ) -> TypeReturnSimulation:
-        """Normal distribution simulation
+        """
+        Simulate normally distributed prices.
 
         Parameters
         ----------
@@ -586,9 +625,8 @@ class ReturnSimulation(BaseModel):
         Returns
         -------
         ReturnSimulation
-            Normal distribution simulation
+            Normally distributed prices
         """
-
         if seed:
             nprandom.seed(seed)
         daily_returns = nprandom.normal(
@@ -607,7 +645,7 @@ class ReturnSimulation(BaseModel):
 
     @classmethod
     def from_lognormal(
-        cls: Type[TypeReturnSimulation],
+        cls: type[TypeReturnSimulation],
         number_of_sims: SimCountType,
         mean_annual_return: float,
         mean_annual_vol: VolatilityType,
@@ -615,7 +653,8 @@ class ReturnSimulation(BaseModel):
         trading_days_in_year: DaysInYearType = 252,
         seed: Optional[int] = 71,
     ) -> TypeReturnSimulation:
-        """Lognormal distribution simulation
+        """
+        Lognormal distribution simulation.
 
         Parameters
         ----------
@@ -638,7 +677,6 @@ class ReturnSimulation(BaseModel):
         ReturnSimulation
             Lognormal distribution simulation
         """
-
         if seed:
             nprandom.seed(seed)
         daily_returns = (
@@ -660,7 +698,7 @@ class ReturnSimulation(BaseModel):
 
     @classmethod
     def from_gbm(
-        cls: Type[TypeReturnSimulation],
+        cls: type[TypeReturnSimulation],
         number_of_sims: SimCountType,
         mean_annual_return: float,
         mean_annual_vol: VolatilityType,
@@ -668,8 +706,11 @@ class ReturnSimulation(BaseModel):
         trading_days_in_year: DaysInYearType = 252,
         seed: Optional[int] = 71,
     ) -> TypeReturnSimulation:
-        """This method constructs a sequence of log returns which, when
-        exponentiated, produce a random Geometric Brownian Motion (GBM)
+        """
+        Geometric Brownian Motion simulation.
+
+        Method constructs a sequence of log returns which, when
+        exponentiated, produce a random Geometric Brownian Motion (GBM).
 
         Parameters
         ----------
@@ -690,9 +731,8 @@ class ReturnSimulation(BaseModel):
         Returns
         -------
         ReturnSimulation
-            Normal distribution simulation
+            Geometric Brownian Motion simulation
         """
-
         if seed:
             nprandom.seed(seed)
 
@@ -706,7 +746,7 @@ class ReturnSimulation(BaseModel):
         daily_returns = []
         for _ in range(number_of_sims):
             daily_returns.append(
-                cls.geometric_brownian_motion_log_returns(param=model_params)
+                cls.geometric_brownian_motion_log_returns(param=model_params),
             )
         return cls(
             number_of_sims=number_of_sims,
@@ -719,7 +759,7 @@ class ReturnSimulation(BaseModel):
 
     @classmethod
     def from_heston(
-        cls: Type[TypeReturnSimulation],
+        cls: type[TypeReturnSimulation],
         number_of_sims: SimCountType,
         trading_days: TradingDaysType,
         mean_annual_return: float,
@@ -729,8 +769,11 @@ class ReturnSimulation(BaseModel):
         trading_days_in_year: DaysInYearType = 252,
         seed: Optional[int] = 71,
     ) -> TypeReturnSimulation:
-        """Heston model is the geometric brownian motion model
-        with stochastic volatility
+        """
+        Heston model simulation.
+
+        Heston model is the geometric brownian motion model
+        with stochastic volatility.
 
         Parameters
         ----------
@@ -757,7 +800,6 @@ class ReturnSimulation(BaseModel):
         ReturnSimulation
             Heston model simulation
         """
-
         if seed:
             nprandom.seed(seed)
 
@@ -788,7 +830,7 @@ class ReturnSimulation(BaseModel):
 
     @classmethod
     def from_heston_vol(
-        cls: Type[TypeReturnSimulation],
+        cls: type[TypeReturnSimulation],
         number_of_sims: SimCountType,
         trading_days: TradingDaysType,
         mean_annual_return: float,
@@ -798,7 +840,8 @@ class ReturnSimulation(BaseModel):
         trading_days_in_year: DaysInYearType = 252,
         seed: Optional[int] = 71,
     ) -> TypeReturnSimulation:
-        """Heston Vol model simulation
+        """
+        Heston Vol model simulation.
 
         Parameters
         ----------
@@ -825,7 +868,6 @@ class ReturnSimulation(BaseModel):
         ReturnSimulation
             Heston Vol model simulation
         """
-
         if seed:
             nprandom.seed(seed)
 
@@ -856,7 +898,7 @@ class ReturnSimulation(BaseModel):
 
     @classmethod
     def from_merton_jump_gbm(
-        cls: Type[TypeReturnSimulation],
+        cls: type[TypeReturnSimulation],
         number_of_sims: SimCountType,
         trading_days: TradingDaysType,
         mean_annual_return: float,
@@ -867,7 +909,8 @@ class ReturnSimulation(BaseModel):
         trading_days_in_year: DaysInYearType = 252,
         seed: Optional[int] = 71,
     ) -> TypeReturnSimulation:
-        """Merton Jump-Diffusion model simulation
+        """
+        Merton Jump-Diffusion model simulation.
 
         Parameters
         ----------
@@ -896,7 +939,6 @@ class ReturnSimulation(BaseModel):
         ReturnSimulation
             Merton Jump-Diffusion model simulation
         """
-
         if seed:
             nprandom.seed(seed)
 
@@ -932,18 +974,19 @@ class ReturnSimulation(BaseModel):
         end: Optional[dt.date] = None,
         countries: CountriesType = "SE",
     ) -> DataFrame:
-        """Creates pandas.DataFrame from the simulation(s)
-
-            Parameters
-            ----------
-            name: str
-                Name label of the serie(s)
-            start: datetime.date, optional
-                Date when the simulation starts
-            end: datetime.date, optional
-                Date when the simulation ends
-            countries: CountriesType, default: "SE"
-                (List of) country code(s) according to ISO 3166-1 alpha-2
+        """
+        Create pandas.DataFrame from simulation(s).
+
+        Parameters
+        ----------
+        name: str
+            Name label of the serie(s)
+        start: datetime.date, optional
+            Date when the simulation starts
+        end: datetime.date, optional
+            Date when the simulation ends
+        countries: CountriesType, default: "SE"
+            (List of) country code(s) according to ISO 3166-1 alpha-2
 
         Returns
         -------
@@ -951,7 +994,10 @@ class ReturnSimulation(BaseModel):
             Object based on the simulation(s)
         """
         d_range = generate_calender_date_range(
-            trading_days=self.trading_days, start=start, end=end, countries=countries
+            trading_days=self.trading_days,
+            start=start,
+            end=end,
+            countries=countries,
         )
 
         if self.number_of_sims == 1:
@@ -968,8 +1014,10 @@ class ReturnSimulation(BaseModel):
         return fdf
 
 
-class ModelParameters(BaseModel):
-    """Object of the class ModelParameters.
+class ModelParameters(BaseModel):  # type: ignore[misc]
+
+    """
+    Object of the class ModelParameters.
 
     Parameters
     ----------