Add sector performance

Author: lsbardel

notebooks/_config.yml

@@ -34,7 +34,8 @@ html:
   use_edit_page_button: true
   use_issues_button: true
   use_repository_button: true
-  google_analytics_id: G-XBNNWQ560T
+  analytics:
+    google_analytics_id: G-XBNNWQ560T
 
 parse:
   myst_enable_extensions:

notebooks/applications/volatility_surface.md

@@ -4,7 +4,7 @@ jupytext:
     extension: .md
     format_name: myst
     format_version: 0.13
-    jupytext_version: 1.14.7
+    jupytext_version: 1.16.6
 kernelspec:
   display_name: Python 3 (ipykernel)
   language: python
@@ -18,50 +18,10 @@ In this notebook we illustrate the use of the Volatility Surface tool in the lib
 First thing, fetch the data
 
 ```{code-cell} ipython3
-from quantflow.data.client import HttpClient
+from quantflow.data.deribit import Deribit
 
-deribit_url = "https://test.deribit.com/api/v2/public/get_book_summary_by_currency"
-async with HttpClient() as cli:
-    futures = await cli.get(deribit_url, params=dict(currency="BTC", kind="future"))
-    options = await cli.get(deribit_url, params=dict(currency="BTC", kind="option"))
-```
-
-```{code-cell} ipython3
-from decimal import Decimal
-from quantflow.options.surface import VolSurfaceLoader, VolSecurityType
-from datetime import timezone
-from dateutil.parser import parse
-
-def parse_maturity(v: str):
-    return parse(v).replace(tzinfo=timezone.utc, hour=8)
-    
-loader = VolSurfaceLoader()
-
-for future in futures["result"]:
-    if (bid := future["bid_price"]) and (ask := future["ask_price"]):
-        maturity = future["instrument_name"].split("-")[-1]
-        if maturity == "PERPETUAL":
-            loader.add_spot(VolSecurityType.spot, bid=Decimal(bid), ask=Decimal(ask))
-        else:
-            loader.add_forward(
-                VolSecurityType.forward,
-                maturity=parse_maturity(maturity),
-                bid=Decimal(str(bid)),
-                ask=Decimal(str(ask))
-            )
-
-for option in options["result"]:
-    if (bid := option["bid_price"]) and (ask := option["ask_price"]):
-        _, maturity, strike, ot = option["instrument_name"].split("-")
-        loader.add_option(
-            VolSecurityType.option,
-            strike=Decimal(strike),
-            maturity=parse_maturity(maturity),
-            call=ot == "C",
-            bid=Decimal(str(bid)),
-            ask=Decimal(str(ask))
-        )
-    
+async with Deribit() as cli:
+    loader = await cli.volatility_surface_loader("eth")
 ```
 
 Once we have loaded the data, we create the surface and display the term-structure of forwards
@@ -72,6 +32,10 @@ vs.maturities = vs.maturities[1:]
 vs.term_structure()
 ```
 
+```{code-cell} ipython3
+vs.spot
+```
+
 ## bs method
 
 This method calculate the implied Black volatility from option prices. By default it uses the best option in the surface for the calculation.
@@ -135,10 +99,11 @@ pricer.model
 ```
 
 ```{code-cell} ipython3
-cal.plot(index=4, max_moneyness_ttm=1)
+cal.plot(index=6, max_moneyness_ttm=1)
 ```
 
-## Serialization
+## 
+Serialization
 
 It is possible to save the vol surface into a json file so it can be recreated for testing or for serialization/deserialization.
 

poetry.lock

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import enum
 from typing import TYPE_CHECKING, Any, Self, cast
 
 import click
@@ -11,6 +12,15 @@
     from quantflow.cli.app import QfApp
 
 
+class HistoricalPeriod(enum.StrEnum):
+    day = "1d"
+    week = "1w"
+    month = "1m"
+    three_months = "3m"
+    six_months = "6m"
+    year = "1y"
+
+
 class QuantContext(click.Context):
 
     @classmethod
@@ -97,3 +107,11 @@ class options:
         help="Chart height",
     )
     chart = click.option("-c", "--chart", is_flag=True, help="Display chart")
+    period = click.option(
+        "-p",
+        "--period",
+        type=click.Choice(tuple(p.value for p in HistoricalPeriod)),
+        default="1d",
+        show_default=True,
+        help="Historical period",
+    )

quantflow/cli/commands/base.py

@@ -1,15 +1,20 @@
 from __future__ import annotations
 
 import asyncio
+from datetime import timedelta
+from typing import cast
 
 import click
 import pandas as pd
 from asciichartpy import plot
+from ccy import period as to_period
 from ccy.cli.console import df_to_rich
+from ccy.tradingcentres import prevbizday
 
 from quantflow.data.fmp import FMP
+from quantflow.utils.dates import utcnow
 
-from .base import QuantContext, quant_group
+from .base import HistoricalPeriod, QuantContext, options, quant_group
 
 FREQUENCIES = tuple(FMP().historical_frequencies())
 
@@ -49,22 +54,8 @@ def search(text: str) -> None:
 
 @stocks.command()
 @click.argument("symbol")
-@click.option(
-    "-h",
-    "--height",
-    type=int,
-    default=20,
-    show_default=True,
-    help="Chart height",
-)
-@click.option(
-    "-l",
-    "--length",
-    type=int,
-    default=100,
-    show_default=True,
-    help="Number of data points",
-)
+@options.height
+@options.length
 @click.option(
     "-f",
     "--frequency",
@@ -84,6 +75,18 @@ def chart(symbol: str, height: int, length: int, frequency: str) -> None:
     print(plot(data, {"height": height}))
 
 
+@stocks.command()
+@options.period
+def sectors(period: str) -> None:
+    """Sectors performance and PE ratios"""
+    ctx = QuantContext.current()
+    data = asyncio.run(sector_performance(ctx, HistoricalPeriod(period)))
+    df = pd.DataFrame(data, columns=["sector", "performance", "pe"]).sort_values(
+        "performance", ascending=False
+    )
+    ctx.qf.print(df_to_rich(df))
+
+
 async def get_prices(ctx: QuantContext, symbol: str, frequency: str) -> pd.DataFrame:
     async with ctx.fmp() as cli:
         return await cli.prices(symbol, frequency)
@@ -97,3 +100,30 @@ async def get_profile(ctx: QuantContext, symbol: str) -> list[dict]:
 async def search_company(ctx: QuantContext, text: str) -> list[dict]:
     async with ctx.fmp() as cli:
         return await cli.search(text)
+
+
+async def sector_performance(
+    ctx: QuantContext, period: HistoricalPeriod
+) -> dict | list[dict]:
+    async with ctx.fmp() as cli:
+        to_date = utcnow().date()
+        if period != HistoricalPeriod.day:
+            from_date = to_date - timedelta(days=to_period(period.value).totaldays)
+            sp = await cli.sector_performance(
+                from_date=prevbizday(from_date, 0).isoformat(),  # type: ignore
+                to_date=prevbizday(to_date, 0).isoformat(),  # type: ignore
+                summary=True,
+            )
+        else:
+            sp = await cli.sector_performance()
+        spd = cast(dict, sp)
+        pe = await cli.sector_pe(params=dict(date=prevbizday(to_date, 0).isoformat()))  # type: ignore
+        pes = {}
+        for k in pe:
+            sector = k["sector"]
+            if sector in spd:
+                pes[sector] = round(float(k["pe"]), 3)
+        return [
+            dict(sector=k, performance=float(v), pe=pes.get(k, float("nan")))
+            for k, v in spd.items()
+        ]

quantflow/cli/commands/stocks.py

@@ -1,24 +1,115 @@
-from typing import Any
+from datetime import datetime, timezone
+from typing import Any, cast
 
 import pandas as pd
+from dateutil.parser import parse
 from fluid.utils.http_client import AioHttpClient, HttpResponse
 
+from quantflow.options.surface import VolSecurityType, VolSurfaceLoader
+from quantflow.utils.numbers import round_to_step
+
+
+def parse_maturity(v: str) -> datetime:
+    return parse(v).replace(tzinfo=timezone.utc, hour=8)
+
 
 class Deribit(AioHttpClient):
     url = "https://www.deribit.com/api/v2"
 
-    async def get_book_summary_by_instrument(self, **kw: Any) -> Any:
-        return await self.get_path("public/get_book_summary_by_instrument", **kw)
+    async def get_book_summary_by_instrument(self, **kw: Any) -> list[dict]:
+        kw.update(callback=self.to_result)
+        return cast(
+            list[dict],
+            await self.get_path("public/get_book_summary_by_instrument", **kw),
+        )
+
+    async def get_book_summary_by_currency(self, **kw: Any) -> list[dict]:
+        kw.update(callback=self.to_result)
+        return cast(
+            list[dict], await self.get_path("public/get_book_summary_by_currency", **kw)
+        )
+
+    async def get_instruments(self, **kw: Any) -> list[dict]:
+        kw.update(callback=self.to_result)
+        return cast(list[dict], await self.get_path("public/get_instruments", **kw))
 
     async def get_volatility(self, **kw: Any) -> pd.DataFrame:
         kw.update(callback=self.to_df)
         return await self.get_path("public/get_historical_volatility", **kw)
 
+    async def volatility_surface_loader(self, currency: str) -> VolSurfaceLoader:
+        """Create the volatility surface loader for a given crypto-currency"""
+        loader = VolSurfaceLoader()
+        futures = await self.get_book_summary_by_currency(
+            params=dict(currency=currency, kind="future")
+        )
+        options = await self.get_book_summary_by_currency(
+            params=dict(currency=currency, kind="option")
+        )
+        instruments = await self.get_instruments(params=dict(currency=currency))
+        instrument_map = {i["instrument_name"]: i for i in instruments}
+
+        for future in futures:
+            if (bid_ := future["bid_price"]) and (ask_ := future["ask_price"]):
+                name = future["instrument_name"]
+                meta = instrument_map[name]
+                tick_size = meta["tick_size"]
+                bid = round_to_step(bid_, tick_size)
+                ask = round_to_step(ask_, tick_size)
+                if meta["settlement_period"] == "perpetual":
+                    loader.add_spot(
+                        VolSecurityType.spot,
+                        bid=bid,
+                        ask=ask,
+                        open_interest=int(future["open_interest"]),
+                        volume=int(future["volume_usd"]),
+                    )
+                else:
+                    maturity = pd.to_datetime(
+                        meta["expiration_timestamp"],
+                        unit="ms",
+                        utc=True,
+                    ).to_pydatetime()
+                    loader.add_forward(
+                        VolSecurityType.forward,
+                        maturity=maturity,
+                        bid=bid,
+                        ask=ask,
+                        open_interest=int(future["open_interest"]),
+                        volume=int(future["volume_usd"]),
+                    )
+
+        for option in options:
+            if (bid_ := option["bid_price"]) and (ask_ := option["ask_price"]):
+                name = option["instrument_name"]
+                meta = instrument_map[name]
+                tick_size = meta["tick_size"]
+                loader.add_option(
+                    VolSecurityType.option,
+                    strike=round_to_step(meta["strike"], tick_size),
+                    maturity=pd.to_datetime(
+                        meta["expiration_timestamp"],
+                        unit="ms",
+                        utc=True,
+                    ).to_pydatetime(),
+                    call=meta["option_type"] == "call",
+                    bid=round_to_step(bid_, tick_size),
+                    ask=round_to_step(ask_, tick_size),
+                )
+
+        return loader
+
+    # Internal methods
+
     async def get_path(self, path: str, **kw: Any) -> dict:
         return await self.get(f"{self.url}/{path}", **kw)
 
-    async def to_df(self, response: HttpResponse) -> pd.DataFrame:
+    async def to_result(self, response: HttpResponse) -> list[dict]:
         data = await response.json()
-        df = pd.DataFrame(data["result"], columns=["timestamp", "volatility"])
+        return cast(list[dict], data["result"])
+
+    async def to_df(self, response: HttpResponse) -> pd.DataFrame:
+        data = await self.to_result(response)
+        df = pd.DataFrame(data, columns=["timestamp", "volatility"])
         df["timestamp"] = pd.to_datetime(df["timestamp"], unit="ms")
         return df