L03 — Mortalità dei token e distorsione da sopravvivenza

import datetime as dt

import matplotlib.pyplot as plt
import numpy as np
import polars as pl

from cvbook.dati import DISCONTINUITA, carica, carica_strumento
from cvbook.metriche import recupero_necessario

luna = carica_strumento("lunausdt").sort("data").filter(pl.col("data") >= dt.date(2022, 4, 1))

with avvio.figura("schermo"):
    fig, ax = plt.subplots()
    ax.semilogy(luna["data"].to_list(), luna["chiusura"].to_numpy(), linewidth=1.6)
    ax.set_ylabel("Prezzo di chiusura (USDT, scala log)")
    fig.autofmt_xdate()
    plt.show()

grezza = carica("lunausdt").sort("data").filter(
    pl.col("data").is_between(dt.date(2022, 4, 1), dt.date(2022, 6, 30))
)

with avvio.figura("schermo"):
    fig, ax = plt.subplots()
    ax.semilogy(grezza["data"].to_list(), grezza["chiusura"].to_numpy(),
                linewidth=1.6, linestyle="--")
    ax.axvline(DISCONTINUITA["lunausdt"], linewidth=1.0, linestyle=":")
    ax.set_ylabel("Prezzo di chiusura (USDT, scala log)")
    ax.set_title("La stessa serie letta grezza: da qui in poi è un altro token")
    fig.autofmt_xdate()
    plt.show()

righe = luna.filter(pl.col("data").is_between(dt.date(2022, 5, 5), dt.date(2022, 5, 13)))
partenza = float(righe["chiusura"][0])
for d, p in zip(righe["data"].to_list(), righe["chiusura"].to_numpy()):
    perdita = 1 - p / partenza
    recupero = recupero_necessario(min(perdita, 0.999999))
    print(f"{d}  {p:12.5f} USDT   perdita {perdita:7.3%}   servirebbe +{recupero:,.0%}")

ftt = carica("fttusdt").sort("data").filter(pl.col("data") >= dt.date(2022, 10, 1))

with avvio.figura("schermo"):
    fig, ax = plt.subplots()
    ax.plot(ftt["data"].to_list(), ftt["chiusura"].to_numpy(), linewidth=1.6, marker="o",
            markersize=2.5)
    ax.set_ylabel("Prezzo di chiusura (USDT)")
    fig.autofmt_xdate()
    plt.show()

print(f"ultimo giorno con un prezzo: {ftt['data'][-1]}  ({float(ftt['chiusura'][-1]):.2f} USDT)")
print("dopo quella data non esiste piu' un mercato: non c'e' un prezzo, non c'e' "
      "una quotazione, non c'e' modo di vendere.")

INIZIO = dt.date(2021, 4, 1)  # ← PROVA / TRY: sposta a gennaio 2022 (vedi esercizio 2)
FINE = dt.date(2022, 12, 31)  # ← PROVA / TRY: porta a oggi e guarda cosa cambia
VIVI = ["btcusdt", "ethusdt", "solusdt"]  # ← PROVA / TRY: togli "solusdt" (esercizio 1)
MORTI = ["lunausdt", "fttusdt"]
# NON TOCCARE / DO NOT CHANGE: MORTI deve restare com'è — sono gli unici due
# token defunti congelati nel registro dati; la dimostrazione è proprio che
# le fonti comode non li avrebbero mai lasciati scegliere (vedi esercizio 3)
# MORTI must stay as it is — these are the only two dead tokens frozen in the
# data registry; the whole demonstration is that convenient sources would
# never have let you choose them (see exercise 3)


def curva_paniere(nomi: list[str]) -> tuple[list, np.ndarray]:
    """Paniere a peso uguale, ribilanciato una sola volta all'inizio.

    Due scelte, e vanno dette perché sono le stesse della figura stampata nel
    libro — altrimenti questo quaderno risponderebbe a una domanda diversa da
    quella del capitolo, che è esattamente ciò che non deve succedere.

    **Un asset delistato non sparisce: resta all'ultimo valore noto.** È quanto
    vale davvero per chi ce l'ha in portafoglio, e non è zero: FTT il 15 novembre
    2022 valeva ancora 1,43 dollari, semplicemente non si poteva più vendere.

    **Le serie si leggono con `carica_strumento`**, che si ferma dove
    l'identificativo cambia strumento. Con la serie grezza LUNA risaliva al 6,8%
    del valore iniziale e il paniere dei morti chiudeva a 30,3 invece che a 29,0:
    questo quaderno avrebbe sottostimato del 7% proprio l'errore che esiste per
    misurare.
    """
    calendario = [
        d for d in carica("btcusdt").sort("data")["data"].to_list()
        if INIZIO <= d <= FINE
    ]
    quote = []
    for n in nomi:
        s = carica_strumento(n).sort("data").filter(
            pl.col("data").is_between(INIZIO, FINE)
        )
        mappa = dict(zip(s["data"].to_list(), s["chiusura"].to_numpy()))
        base = mappa[min(mappa)]
        ultimo, riempita = base, []
        for d in calendario:
            ultimo = mappa.get(d, ultimo)
            riempita.append(ultimo / base)
        quote.append(riempita)
    return calendario, np.mean(np.array(quote), axis=0)


date_v, solo_vivi = curva_paniere(VIVI)
date_t, tutti = curva_paniere(VIVI + MORTI)

with avvio.figura("schermo"):
    fig, ax = plt.subplots()
    ax.plot(date_v, solo_vivi * 100, linewidth=1.8, label="solo i sopravvissuti")
    ax.plot(date_t, tutti * 100, linewidth=1.8, linestyle="--",
            label="tutti, morti compresi")
    ax.axhline(100, linestyle=":", linewidth=0.9)
    ax.set_ylabel("Capitale (base 100)")
    ax.legend()
    fig.autofmt_xdate()
    plt.show()

print(f"paniere dei soli sopravvissuti: {solo_vivi[-1] * 100:.1f}")
print(f"paniere reale, morti compresi:  {tutti[-1] * 100:.1f}")
print(f"differenza:                     {tutti[-1] / solo_vivi[-1] - 1:+.1%}")