Yfinance + yahooquery para opciones + Gráficos P&L

En otro artículo nos enfocamos en el potencial de yfinance a la hora de extraer y analizar información ,pero ahora dejadme que os hable de una librería que he descubierto recientemente: yahooquery

Yahooquery es una interfaz en Python para la API de Yahoo Finance. El paquete permite al usuario recuperar casi todos los datos visibles a través de la interfaz de Yahoo Finance.

Algunas características de yahooquery:

• Rápido : los datos se recuperan a través de endingpoints de la API en lugar de web scraping. Además, las solicitudes asincrónicas se pueden utilizar con una configuración simple.
• Sencillo : los datos de varios símbolos se pueden recuperar con frases sencillas.
• Fácil de usar : los marcos de datos de Pandas se utilizan cuando corresponde.
• Premium : los suscriptores premium de Yahoo Finance pueden recuperar los datos disponibles a través de su suscripción.

La clase Ticker de yahooquery nos permite trabajar con múltiples activos sin necesidad de crear bucles para extraer información.

Para el siguiente ejemplo, estamos utilizando la clase Ticker para pasarle la lista "FAANG" y que nos realice las consultas de forma asíncrona. Luego utilizamos options_chain para crear el DataFrame para todos los vencimientos y contratos disponibles especificados en nuestra variable lista.

import pandas as pd
from yahooquery import Ticker

FAANG = ['FB', 'AMZN', 'AAPL', 'NFLX','GOOG' ]

t = Ticker(FAANG, asynchronous=True)
df = pd.DataFrame(t.option_chain)

Con el método unique y el parámetro level podemos mostrar los diferentes índices (Multiindex) sobre los que está compuesto este DataFrame. Concretamente tiene 3 niveles: En el primero tenemos nuestros activos, en el segundo los vencimientos disponibles, y en el tercero el tipo de producto Call o Put

print(df.index.unique(level=0))
print(df.index.unique(level=1))
print(df.index.unique(level=2))

Con shape y columns podemos ver qué tan grande es el DataFrame y qué columnas tiene:

print(df.shape)
print(df.columns)

Las 14 columnas corresponden al número de activos.

Podemos hacer los filtros que se nos ocurran.

Por ejemplo, el de mostrar únicamente las calls para todos los activos (la mitad del DataFrame) o sacar únicamente las opciones que estén ITM de algún activo en concreto (NFLX), con el método xs (para índices múltiples). Al final podemos utilizar comandos como si fuera un screener para mostrar lo que queramos.

print(df.xs('calls', level=2))
print(df[df['inTheMoney'] == True].xs('NFLX'))

Algunos ejemplos más:

df[df['volume'] > 10000]
df[df['openInterest'] > 100000]
df[df['impliedVolatility'] > 0.3]

yahooquery nos permite realizar lo mismo que con yfinance pero de forma más eficiente, podréis ver la diferencia en relación a yfinance con los ejemplos mostrados en vídeo más adelante.

A continuación os quiero mostrar cómo realizar gráficos Profit&Loss de opciones. Podemos basarnos en la información descargada de yfinance para consturirlos. Vamos a tratar de recrear los datos de este vencimiento en específico:

print(df.loc['AAPL', '2021-06-25', 'calls'])

Para nuestras Calls supondremos un strike de 131 y un premium de 1,25. Ahora vamos a descubrir a cuánto cotiza el subyacente, empezaremos con una compra (Long Call).

Debemos empezar un programa nuevo:

import pandas_datareader.data as wb
import numpy as np
import matplotlib.pyplot as plt

Podemos descargarnos el último precio con DataReader

S = wb.DataReader('AAPL', 'yahoo')['Adj Close'][-1]

Cotiza aproximadamente a 130.

Creamos dos variables numéricas con el strike y la prima:

strike_calls = 130
premium_c = 1.25

A continuación debemos aproximar un rango para el eje de las x que sea proporcional para poder observar los cambios en la pendiente y el momento de breakeven, se intenta simular nuestro precio del subyacente a expiración.

C_exp = np.arange(0.95*S, 1.10*S, 1)

Ahora necesitamos crear una condición para que cuando nuestro precio de expiración sea mayor al strike, nos haga la resta entre el precio a expiración y el strike, para cada valor  (C_exp > strike_calls = C_exp - strike_calls).

En caso contrario necesitamos que nos ponga 0, y que siempre nos reste el precio de la prima, ya que estamos comprados.

long_call = np.where(C_exp > strike_calls, C_exp - strike_calls, 0) - premium_c

Ya podríamos pasar a graficar nuestra opción:

fig, ax = plt.subplots()
ax.plot(C_exp, long_call, color='r')
plt.title("Long Call")
plt.xlabel("Precio a vencimiento")
plt.ylabel("P&L")
ax.spines['top'].set_visible(False)
ax.spines['right'].set_visible(False)
ax.spines['bottom'].set_position('zero')
plt.show()

Para hacer una Short Call, podemos multiplicar por -1. 

call_short = -1*long_call

Para las ventas nos estarían ingresando la prima, y habría que sumarla.

Para las puts el proceso es parecido:

P_exp = np.arange(0.85*S , 1.00*S, 1)
long_put = np.where(P_exp < strike_puts, strike_puts - P_exp, 0) - premium_p
put_short = -1*long_put

La condición cambia en el caso de las compras en relación a las calls: (P_exp < strike_puts = strike_puts - P_exp)