More docs

Author: lsbardel

notebooks/api/data/deribit.rst

@@ -0,0 +1,11 @@
+================
+Deribit
+================
+
+.. currentmodule:: quantflow.data.deribit
+
+.. autoclass:: Deribit
+   :members:
+   :member-order: groupwise
+   :autosummary:
+   :autosummary-nosignatures:

notebooks/api/data/fmp.rst

@@ -0,0 +1,11 @@
+================
+FMP
+================
+
+.. currentmodule:: quantflow.data.fmp
+
+.. autoclass:: FMP
+   :members:
+   :member-order: groupwise
+   :autosummary:
+   :autosummary-nosignatures:

notebooks/api/data/fred.rst

@@ -0,0 +1,11 @@
+================
+Fred
+================
+
+.. currentmodule:: quantflow.data.fred
+
+.. autoclass:: Fred
+   :members:
+   :member-order: groupwise
+   :autosummary:
+   :autosummary-nosignatures:

notebooks/api/data/index.rst

@@ -4,3 +4,15 @@ Data fetching
 
 .. currentmodule:: quantflow.data
 
+The :mod:`quantflow.data` module provides classes and functions for fetching data from various sources.
+To use the module the package must be installed with the optional `data` extra.
+```
+pip install quantflow[data]
+```
+
+.. toctree::
+    :maxdepth: 1
+
+    fmp
+    fred
+    deribit

notebooks/api/sp/heston.rst

@@ -10,3 +10,9 @@ Heston process
    :autosummary:
    :autosummary-nosignatures:
 
+
+.. autoclass:: HestonJ
+   :members:
+   :member-order: groupwise
+   :autosummary:
+   :autosummary-nosignatures:

notebooks/reference/glossary.md

@@ -45,9 +45,20 @@ Moneyness is used in the context of option pricing and it is defined as
 
 where $K$ is the strike and $F$ is the Forward price. A positive value implies strikes above the forward, which means put options are in the money and call options are out of the money.
 
-```{code-cell}
 
-```
+## Moneyness Time Adjusted
+
+The time-adjusted moneyness is used in the context of option pricing in order to compare options with different maturities. It is defined as
+
+\begin{equation}
+    \frac{1}{\sqrt{T}}\ln\frac{K}{F}
+\end{equation}
+
+where $K$ is the strike and $F$ is the Forward price and $T$ is the time to maturity.
+
+The key reason for dividing by the square root of time-to-maturity is related to how volatility and price movement behave over time.
+The price of the underlying asset is subject to random fluctuations, if these fluctuations follow a Brownian motion than the
+standard deviation of the price movement will increase with the square root of time.
 
 ## Probability Density Function (PDF)
 

poetry.lock

@@ -24,6 +24,7 @@ aio-fluid = {version = "^1.2.1", extras=["http"], optional = true}
 rich = {version = "^13.9.4", optional = true}
 click = {version = "^8.1.7", optional = true}
 holidays = {version = "^0.63", optional = true}
+async-cache = {version = "^1.1.1", optional = true}
 
 [tool.poetry.group.dev.dependencies]
 black = "^24.1.1"
@@ -37,7 +38,14 @@ isort = "^5.13.2"
 
 [tool.poetry.extras]
 data = ["aio-fluid"]
-cli = ["asciichartpy", "prompt-toolkit", "rich", "click", "holidays"]
+cli = [
+    "asciichartpy",
+    "async-cache",
+    "prompt-toolkit",
+    "rich",
+    "click",
+    "holidays"
+]
 
 [tool.poetry.group.book]
 optional = true
@@ -89,6 +97,7 @@ warn_no_return = true
 [[tool.mypy.overrides]]
 module = [
     "asciichartpy.*",
+    "cache.*",
     "quantflow_tests.*",
     "IPython.*",
     "pandas.*",

pyproject.toml

@@ -115,3 +115,10 @@ class options:
         show_default=True,
         help="Historical period",
     )
+    index = click.option(
+        "-i",
+        "--index",
+        type=int,
+        default=-1,
+        help="maturity index",
+    )

quantflow/cli/commands/base.py

@@ -5,9 +5,11 @@
 import click
 import pandas as pd
 from asciichartpy import plot
+from cache import AsyncTTL
 from ccy.cli.console import df_to_rich
 
 from quantflow.data.deribit import Deribit
+from quantflow.options.surface import VolSurface
 
 from .base import QuantContext, options, quant_group
 
@@ -36,6 +38,48 @@ def volatility(currency: str, length: int, height: int, chart: bool) -> None:
         ctx.qf.print(df_to_rich(df))
 
 
+@crypto.command()
+@click.argument("currency")
+def term_structure(currency: str) -> None:
+    """Provides information about the term structure for given cryptocurrency"""
+    ctx = QuantContext.current()
+    vs = asyncio.run(get_vol_surface(currency))
+    ts = vs.term_structure().round({"ttm": 4})
+    ts["open_interest"] = ts["open_interest"].map("{:,d}".format)
+    ts["volume"] = ts["volume"].map("{:,d}".format)
+    ctx.qf.print(df_to_rich(ts))
+
+
+@crypto.command()
+@click.argument("currency")
+@options.index
+@options.height
+@options.chart
+def implied_vol(currency: str, index: int, height: int, chart: bool) -> None:
+    """Display the Volatility Surface for given cryptocurrency
+    at a given maturity index
+    """
+    ctx = QuantContext.current()
+    vs = asyncio.run(get_vol_surface(currency))
+    index_or_none = None if index < 0 else index
+    vs.bs(index=index_or_none)
+    df = vs.options_df(index=index_or_none)
+    df["implied_vol"] = df["implied_vol"] * 100
+    df = df.round({"ttm": 4, "moneyness": 4, "moneyness_ttm": 4, "implied_vol": 5})
+    if chart:
+        data = df["implied_vol"].tolist()
+        ctx.qf.print(plot(data, {"height": height}))
+    else:
+        ctx.qf.print(df_to_rich(df))
+
+
 async def get_volatility(ctx: QuantContext, currency: str) -> pd.DataFrame:
     async with Deribit() as client:
         return await client.get_volatility(params=dict(currency=currency))
+
+
+@AsyncTTL(time_to_live=10)
+async def get_vol_surface(currency: str) -> VolSurface:
+    async with Deribit() as client:
+        loader = await client.volatility_surface_loader(currency)
+        return loader.surface()