def copiar_fondos_a_cartera(fecha, instrumentos, empresas, cnn):
"""
Copia los elementos desde TdDerivadosFondo a TdCarteraDerivados según la fecha, instrumentos y empresa
:param fecha: datetime.date
:param instrumentos: arr
:param empresas: arr
:param cnn: pyodbc.connect
:return:
"""
borrar_admin = str_condicion(empresas, "Administradora")
borrar_instr = str_condicion(instrumentos, "ID")
# Primero borramos los elementos
sql = ("DELETE FROM dbDerivados.dbo.TdCarteraDerivados_V2 "
"WHERE Fecha = " + fecha_str(fecha) + " AND " + borrar_admin +
" AND " + borrar_instr)
# Ahora los traemos de TdDerivadosFondo
inserta_empresa = str_condicion(empresas, "idEmpresa")
inserta_instrumeto = str_condicion(instrumentos, "idInstrumento")
sql = (
"INSERT INTO dbDerivados.dbo.TdCarteraDerivados_V2 "
"([Fecha] ,[Administradora], [Fondo], [Contraparte], [Tipo], [ID], "
"[FechaTransaccion], [FechaFixing], [FechaEfectiva], [FechaVenc], "
"[AjusteFeriados], [Mercado], [Nemotecnico], [Referencia], [NocionalActivo], "
"[MonedaActivo], [FrecuenciaActivo], [TipoTasaActivo], [TasaActivo], "
"[SpreadActivo], [NocionalPasivo], [MonedaPasivo], [FrecuenciaPasivo], "
"[TipoTasaPasivo], [TasaPasivo], [SpreadPasivo], [MonedaBase]) "
""
"SELECT Fecha, idEmpresa AS Administradora, Fondo, Contraparte, Tipo, "
"idInstrumento, FechaTransaccion, FechaFixing, FechaEfectiva, FechaVenc, "
"AjusteFeriados, Mercado, Nemotecnico, Referencia, NocionalActivo, "
"MonedaActivo, FrecuenciaActivo, TipoTasaActivo, TasaActivo, "
"SpreadActivo, NocionalPasivo, MonedaPasivo, FrecuenciaPasivo, "
"TipoTasaPasivo, TasaPasivo, SpreadPasivo, MonedaBase "
"FROM dbSectorReal.dbo.TdDerivadosFondo "
"WHERE Fecha = " + fecha_str(fecha) + " AND " + inserta_empresa +
" AND " + inserta_instrumeto)
def tipo_cambio(moneda1, moneda2, fecha, hora, cn):
arr = ("SELECT * "
"FROM dbAlgebra.dbo.VwMonedas_Temp Vw1 "
"WHERE Plazo360 = 0 AND Hora = '" + hora +
"' AND Tipo = 'TipoCambio' "
"AND Fecha = " + fecha_str(fecha) + " AND Campo = 'PX_LAST'")
arr = pd.io.sql.read_sql(arr, cn)
camino = ("SELECT * FROM dbDerivados.dbo.FnCaminoMonedas()")
camino = pd.io.sql.read_sql(camino, cn)
return valor_moneda(moneda1, moneda2, camino, arr)
def fecha_hora_valores(fechaActual, cn):
"""
Retorna la fecha en que se deben obtener valores en base de datos
"""
sql = """SELECT Curva, FechaMax, C.Hora, C.Moneda
FROM dbDerivados.dbo.TdCurvasDerivados A, dbDerivados.dbo.TdParidadMonedasCurvasDescuento B,
(SELECT MAX(Fecha) AS FechaMax, Hora, Moneda
FROM dbDerivados.dbo.TdCurvasDerivados A, dbDerivados.dbo.TdParidadMonedasCurvasDescuento B
WHERE A.Tipo = B.Tipo AND Fecha <= @Fecha GROUP BY Hora, Moneda) C
WHERE A.Tipo = B.Tipo AND A.Fecha = C.FechaMax AND A.Hora = C.Hora AND B.Moneda = C.Moneda
ORDER BY Fecha DESC, Hora DESC"""
sql = sql.replace("@Fecha", fecha_str(fechaActual))
datos = pd.io.sql.read_sql(sql, cn)
return (datos.FechaMax.iloc[0].to_pydatetime().date(), datos.Hora.iloc[0])
def siguiente_habil_pais(fecha, pais, cn):
"""Retorna el día hábil siguiente a la fecha en el país indicado
:param fecha: datetime.date con la fecha que se desea el día hábil siguiente
:param pais: String con el código de país ("BR","MX","US"...)
:param cn: pyodbc.connect conexión a base de datos
:return: datetime.date con el día hábil siguiente
"""
# Si la fecha es inválida
if fecha == datetime.date(1900, 1, 1):
return datetime.date(1900, 1, 1)
# Países en TdFeriados
paises = ["BR", "MX", "US", "CO", "UK", "PE", "CR", "RD"]
if pais in paises:
# Hábil mínimo y máximo en TdFeriados
sql = ("SELECT MAX(fecha) AS maxi, MIN(fecha) AS mini "
"FROM dbAlgebra.dbo.TdFeriados "
"WHERE Pais='" + pais + "' AND SiHabil=1")
else: # elseif pais = 'CL'
# Hábil mínimo y máximo en TdIndicadores
sql = ("SELECT MAX(fecha) AS maxi, MIN(fecha) AS mini "
"FROM dbAlgebra.dbo.TdIndicadores "
"WHERE Feriado = 0")
# Se consulta y extrae hábil máximo y mínimo
fechas = pd.io.sql.read_sql(sql, cn)
fecha_max = fechas.iloc[0]['maxi'].to_pydatetime().date()
fecha_min = fechas.iloc[0]['mini'].to_pydatetime().date()
if fecha_min <= fecha <= fecha_max and pais != "--":
sql += " AND Fecha > " + fecha_str(fecha)
fecha = pd.io.sql.read_sql(sql, cn).iloc[0]['mini'].to_pydatetime().date()
else:
fecha = add_days(fecha, 1)
# Si es domingo
if fecha.weekday() == 6:
fecha = add_days(fecha, 1)
# Si es sábado
elif fecha.weekday() == 5:
fecha = add_days(fecha, 2)
return fecha
def get_tabla_desarrollo_fecha_emision_EX(fecha, nemo, cn):
fecha = fecha_str(fecha)
sql = ("SELECT T.Cupon, T.FechaCupon, T.FechaCupon, T.Interes, T.Amortizacion, 0 as Saldo, T.Flujo "
"FROM TdTablasdeDesarrolloExt T INNER JOIN (SELECT Min(Fecha) as Fecha, Nemotecnico FROM ("
"SELECT MAX(Fecha) AS Fecha, Nemotecnico FROM dbalgebra.dbo.TdTablasdeDesarrolloExt "
"WHERE Nemotecnico = '" + nemo + "' AND Fecha <= '" + fecha + "' GROUP BY Nemotecnico "
"UNION "
"SELECT MIN(Fecha) AS Fecha, Nemotecnico "
"FROM dbalgebra.dbo.TdTablasdeDesarrolloExt "
"WHERE Nemotecnico = '" + nemo + "' AND Fecha > '" + fecha + "' GROUP BY Nemotecnico) A "
"GROUP BY Nemotecnico) FN ON T.Fecha = FN.Fecha AND T.Nemotecnico = FN.Nemotecnico "
"ORDER BY T.Cupon")
arr_aux = pd.io.sql.read_sql(sql, cn).values
for i in range(len(arr_aux)-1, -1, -1):
arr_aux[i][5] = arr_aux[i+1][5] + arr_aux[i+1][4]
return arr_aux
def get_tabla_desarrollo_fecha_emision(fecha, nemo, familia, cn):
fecha = fecha_str(fecha)
sql = ("SELECT TOP 1 FechaEmision, TablaDesarrollo "
"FROM (SELECT Fecha, FechaEmision, TablaDesarrollo, 1 AS Prioridad "
"FROM dbAlgebra.dbo.TdNemoRF WHERE Nemotecnico = '" + nemo + "' AND Fecha <= " + fecha + ""
"UNION ALL "
"SELECT Fecha, FechaEmision, TablaDesarrollo, 2 AS Prioridad "
"FROM dbAlgebra.dbo.TdNemoRF WHERE Nemotecnico = '" + nemo + "' AND Fecha > " + fecha + ""
") A "
"ORDER BY Prioridad, Fecha DESC")
arr = pd.io.sql.read_sql(sql, cn)
fecha_emision = arr.FechaEmision.iloc[0]
tabla = arr.TablaDesarrollo.iloc[0]
res = []
res.append([0, fecha_emision, 0, 0, 100, 0])
filas = tabla.split('|')
for fila in filas:
res.append(fila.split("#"))
return res
def crear_objeto(fecha, hora, instrumentos, empresas, cn):
"""
Crea un objeto de empresa para valorizar derivados con las condiciones
:param fecha: datetime.date
:param hora: string
:param instrumentos: arr
:param empresas: arr
:param cn: pyodbc.connect
:return: Empresa
"""
str_condicion(empresas, "Administradora")
str_condicion(instrumentos, "ID")
condicion = "WHERE Fecha = " + fecha_str(fecha) + " AND " + str_condicion(empresas, "Administradora") + \
" AND " + str_condicion(instrumentos, "ID")
sql = ("SELECT * FROM [dbDerivados].[dbo].[TdCarteraDerivados_V2] " +
condicion)
info = pd.io.sql.read_sql(sql, cn)
return Empresa(fecha, hora, info, cn)
def curva_efectiva(moneda, fecha, mercado, hora, filtro, cn):
""" Entrega los plazos y factores de descuento para flujos en la moneda correspondiente en un dataframe de pandas
:param moneda:
:param fecha:
:param mercado:
:param hora:
:param filtro:
:param cn:
:return: dataframe de pandas con la información de plazos y factores de descuento
"""
mercado = cast_mercado(mercado, moneda)
moneda = cast_moneda(moneda)
if mercado == "--":
m2 = ""
else:
m2 = "_" + mercado
arr = []
if filtro == -2:
# Puntos de la curva de 1 a 365 dias
for i in range(365+1): # +1 para que incluya el 365
arr.append(i)
# Puntos de la curva de 30 días en 30 días durante 10 años
for i in range(1, 10*12+1): # +1 para que incluya el 10+12
arr.append(i*30 + 365)
# Puntos de la curva de 180 días en 180 días durante 20 años
for i in (1, 20*2 + 1): # +1 para que se incluya el 20*2
arr.append((i * 180) + (10 * 12 * 30) + 365)
# Se genera un string para todos los plazos
plazos = arr[0]
for i in range(1, len(arr)):
plazos = plazos + ", " + arr[i]
sql = ("SELECT DATEADD(day, Plazo, Fecha) AS Fecha, Plazo, Valor as FD, "
"ROUND(CASE WHEN Plazo = 0 THEN 0 ELSE 1/Power(Valor,Cast(360 AS float)/Plazo)-1 End * 100,2) as Act360 "
"FROM [dbDerivados].[dbo].[FnCompletaCurvasDerivados] "
"(" + fecha_str(fecha) + ",'" + hora + "','CurvaEfectiva_" + moneda + m2 +"', " + arr[-1] + ",'Log',1)"
"WHERE Plazo in (" + plazos + ") ORDER BY Plazo")
elif filtro == -1: # básicos
sql = ("SELECT DATEADD(day, Plazo, Fecha) AS Fecha, Plazo, Valor as FD, "
"ROUND(CASE WHEN Plazo = 0 THEN 0 ELSE 1/Power(Valor,Cast(360 AS float)/Plazo)-1 End * 100,2) as Act360 "
"FROM [dbDerivados].[dbo].[FnParseaCurvasDerivados] "
"(" + fecha_str(fecha) + ", '" + hora + "', 'CurvaEfectiva_" + moneda + m2 + "') "
"ORDER BY Plazo")
elif filtro == 0: # completa hasta donde se pueda
sql = ("SELECT DATEADD(day, Plazo, Fecha) AS Fecha, Plazo, Valor as FD, "
"ROUND(CASE WHEN Plazo = 0 THEN 0 ELSE 1/Power(Valor,Cast(360 AS float)/Plazo)-1 End * 100,2) as Act360 "
"FROM [dbDerivados].[dbo].[FnCompletaCurvasDerivados] "
"(" + fecha_str(fecha) + ",'" + hora + "','CurvaEfectiva_" + moneda + m2 + "', -1, 'Log',1) "
"ORDER BY Plazo")
elif filtro > 0: # completa hasta un plazo fijo
sql = ("SELECT DATEADD(day, Plazo, Fecha) AS Fecha, Plazo, Valor as FD, "
"ROUND(CASE WHEN Plazo = 0 THEN 0 ELSE 1/Power(Valor,Cast(360 AS float)/Plazo)-1 End * 100,2) as Act360 "
"FROM [dbDerivados].[dbo].[FnCompletaCurvasDerivados] "
"(" + fecha_str(fecha) + ",'" + hora + "','CurvaEfectiva_" + moneda + m2 + "'," + str(filtro) + ", 'Log',1) "
"ORDER BY Plazo")
return pd.io.sql.read_sql(sql, cn)
def agrega_cambio_spot(self):
fechas_tipo_cambio_spot = list()
for i in range(len(self.flujos_valorizados)):
plazo_pago = (self.flujos_valorizados.FechaPago.iloc[i] - self.fechaActual).days
plazo_flujo = (self.flujos_valorizados.FechaFlujo.iloc[i] - self.fechaActual).days
plazo_fixing = (self.flujos_valorizados.FechaFixing.iloc[i] - self.fechaActual).days
if plazo_flujo > 0:
plazo_flujo = 0
if plazo_pago > 0:
plazo_pago = 0
if plazo_fixing > 0:
plazo_fixing = 0
fechas_tipo_cambio_spot.append(fecha_str(add_days(self.fechaActual, plazo_fixing)))
fechas_tipo_cambio_spot.append(fecha_str(add_days(self.fechaActual, plazo_pago)))
fechas_tipo_cambio_spot.append(fecha_str(add_days(self.fechaActual, plazo_flujo)))
fechas_tipo_cambio_spot = list(set(fechas_tipo_cambio_spot))
fechas_tipo_cambio_spot = str(fechas_tipo_cambio_spot)[1:-1].replace('"', "")
sql_monedas_cierre = ("SELECT M.Fecha, M.FechaDato, M.MonedaActiva, M.MonedaPasiva, M.Valor, "
"'Spot' as SpotObservado FROM dbDerivados.dbo.VwMonedasDia M "
"WHERE (M.Plazo360 = 0) AND (M.Hora = '" + self.hora + "') AND (M.Tipo = 'TipoCambio') "
"AND (M.Fecha in (" + fechas_tipo_cambio_spot + ")) AND (M.Campo = 'PX_LAST')")
sql_monedas_observadas = ("SELECT Fecha, FechaDato, MonedaActiva, MonedaPasiva, Valor "
"FROM dbDerivados.dbo.VwMonedasObservadas "
"WHERE Fecha in (" + fechas_tipo_cambio_spot + ")")
sql_monedas_observadas_parchadas = ("SELECT DISTINCT Coalesce(O.Fecha, S.Fecha) as Fecha, "
"Coalesce(O.FechaDato, S.FechaDato) as FechaDato, "
"Coalesce(O.MonedaActiva, S.MonedaActiva) as MonedaActiva, "
"Coalesce(O.MonedaPasiva, S.MonedaPasiva) as MonedaPasiva, "
"Coalesce(O.Valor, S.Valor) as Valor, 'Observado' as SpotObservado "
"FROM (" + sql_monedas_cierre + ") AS S "
"FULL OUTER JOIN (" + sql_monedas_observadas + ") AS O "
"ON S.Fecha = O.Fecha AND S.MonedaActiva = O.MonedaActiva "
"AND S.MonedaPasiva = O.MonedaPasiva")
camino_monedas = ("SELECT * FROM dbDerivados.dbo.FnCaminoMonedas()")
sql_monedas = sql_monedas_observadas_parchadas + " UNION " + sql_monedas_cierre
cast_monedas = {'UF': 'CLF', 'CLN': 'COP'}
valores_monedas = pd.io.sql.read_sql(sql_monedas, self.cn)
camino_monedas = pd.io.sql.read_sql(camino_monedas, self.cn)
for i in range(len(self.flujos_valorizados)):
d1 = self.flujos_valorizados.FactorDescMonBase.iloc[i]
d2 = self.flujos_valorizados.FactorDescMonFlujoFix.iloc[i]
d3 = self.flujos_valorizados.FactorDescMonBaseFix.iloc[i]
flujo = self.flujos_valorizados.Flujo.iloc[i]
moneda = cast_monedas.get(self.flujos_valorizados.Moneda.iloc[i], self.flujos_valorizados.Moneda.iloc[i])
moneda_base = cast_monedas.get(self.flujos_valorizados.MonedaBase.iloc[i],
self.flujos_valorizados.MonedaBase.iloc[i])
valores_monedas_t = valores_monedas.loc[valores_monedas['Fecha'] == pd.Timestamp(self.fechaActual)]
valores_monedas_t = valores_monedas_t.loc[valores_monedas_t['SpotObservado'] == 'Spot']
tipo_cambio_t = valor_moneda(moneda, moneda_base, camino_monedas, valores_monedas_t)
if tipo_cambio_t is None:
self.set_status("ERROR: valor_moneda: No se encontró camino para " + moneda + " " + moneda_base +
" en derivado con ID: " + str(self.info_cartera.ID.iloc[0]))
return
plazo_fixing = (self.flujos_valorizados.FechaFixing.iloc[i] - self.fechaActual).days
if plazo_fixing > 0:
plazo_fixing = 0
valores_monedas_fix = valores_monedas.loc[valores_monedas['Fecha'] == pd.Timestamp(add_days(self.fechaActual,
plazo_fixing))]
if plazo_fixing >= 0:
valores_monedas_fix = valores_monedas_fix.loc[valores_monedas_fix['SpotObservado'] == 'Spot']
else:
valores_monedas_fix = valores_monedas_fix.loc[valores_monedas_fix['SpotObservado'] == 'Observado']
tipo_cambio_fix = valor_moneda(moneda, moneda_base, camino_monedas, valores_monedas_fix)
if tipo_cambio_fix is None:
self.set_status("ERROR: valor_moneda: No se encontró camino para " + moneda + " " + moneda_base +
" en derivado con ID: " + str(self.info_cartera.ID.iloc[0]))
return
self.flujos_valorizados.TipoCambioSpot.iloc[i] = tipo_cambio_t
self.flujos_valorizados.TipoCambioSpotFix.iloc[i] = tipo_cambio_fix
valor_presente_mon_base = d1 * flujo * (d2 / d3) * tipo_cambio_t
self.flujos_valorizados.ValorPresenteMonBase.iloc[i] = valor_presente_mon_base
self.flujos_valorizados.TipoCambioFwd.iloc[i] = (d2 / d3) * tipo_cambio_t
# Agregando valores CLP y USD
cambio_usd_base = valor_moneda(moneda_base, "USD", camino_monedas, valores_monedas)
cambio_clp_base = valor_moneda(moneda_base, "CLP", camino_monedas, valores_monedas)
self.flujos_valorizados.TipoCambioCLPBase.iloc[i] = cambio_clp_base
self.flujos_valorizados.TipoCambioUSDBase.iloc[i] = cambio_usd_base
self.flujos_valorizados.ValorPresenteUSD.iloc[i] = valor_presente_mon_base * cambio_usd_base
self.flujos_valorizados.ValorPresenteCLP.iloc[i] = valor_presente_mon_base * cambio_clp_base
self.set_status("INFO: Cambio Spot agregado con éxito")
def valoriza_flujos(self):
"""
Valoriza los flujos y los guarda en el atributo flujos_valorizados
Si no se ha llamado al método genera_flujos puede lanzar error
:return: None
"""
col_tabla_aux = ['Fecha', 'Fondo', 'Tipo', 'ID', 'Hora', 'Mercado',
'ActivoPasivo', 'FechaFixing', 'FechaFlujo', 'FechaPago', 'Moneda', 'Flujo', 'Amortizacion',
'Interes', 'MonedaBase', 'Sensibilidad']
tabla_aux = pd.DataFrame(columns=col_tabla_aux)
for i in range(len(self.flujos_derivados)):
dic = dict()
dic["Fecha"] = self.flujos_derivados.Fecha.iloc[i]
dic["Fondo"] = self.flujos_derivados.Fondo.iloc[i]
dic["Tipo"] = self.flujos_derivados.Tipo.iloc[i]
dic["ID"] = self.flujos_derivados.ID.iloc[i]
dic["Hora"] = self.hora
dic["Mercado"] = self.info_cartera.Mercado.iloc[0]
dic["ActivoPasivo"] = self.flujos_derivados.ActivoPasivo.iloc[i]
dic["FechaFixing"] = self.flujos_derivados.FechaFixing.iloc[i]
dic["FechaFlujo"] = self.flujos_derivados.FechaFlujo.iloc[i]
dic["FechaPago"] = self.flujos_derivados.FechaPago.iloc[i]
dic["Moneda"] = self.flujos_derivados.Moneda.iloc[i]
dic["Flujo"] = self.flujos_derivados.Flujo.iloc[i]
dic["Amortizacion"] = self.flujos_derivados.Amortizacion.iloc[i]
dic["Interes"] = self.flujos_derivados.Interes.iloc[i]
dic["MonedaBase"] = self.info_cartera.MonedaBase.iloc[0]
dic["Sensibilidad"] = self.flujos_derivados.Sensibilidad.iloc[i]
tabla_aux = tabla_aux.append(dic, ignore_index=True)
tabla_aux = tabla_aux.reset_index()
cast_monedas = {'UF': 'CLF', 'CLN': 'COP'}
plazos_monedas = pd.DataFrame(columns=['Moneda', 'Fecha', 'Plazo'])
for i in range(len(tabla_aux)):
insert = dict()
insert["Fecha"] = tabla_aux.Fecha.iloc[i]
insert["Plazo"] = (tabla_aux.FechaPago.iloc[i] - tabla_aux.Fecha.iloc[i]).days
insert["Moneda"] = cast_monedas.get(tabla_aux.Moneda.iloc[i], tabla_aux.Moneda.iloc[i])
plazos_monedas = plazos_monedas.append(insert, ignore_index=True)
insert["Moneda"] = cast_monedas.get(tabla_aux.MonedaBase.iloc[i], tabla_aux.MonedaBase.iloc[i])
plazos_monedas = plazos_monedas.append(insert, ignore_index=True)
# Nos quedamos con el maximo plazo para cada par Moneda,Fecha
plazos_monedas = plazos_monedas.sort_values('Plazo', ascending=False).drop_duplicates(
['Moneda', 'Fecha']).reset_index()
# mercado_curvas = pd.DataFrame([['Ambos', '--'],
# ['Ambos', 'Local'],
# ['--', '--'],
# ['Local', 'Local']], columns=['Mercados', 'Mercado'])
curvas_monedas = {}
monedas_str = ""
for moneda in plazos_monedas.Moneda.drop_duplicates():
curvas_monedas[moneda] = ""
monedas_str += "'" + moneda + "',"
monedas_str = monedas_str[0:-1]
# Se obtienen las curvas
curvas = ("SELECT Curva, FechaMax, C.Hora, C.Moneda "
"FROM dbDerivados.dbo.TdCurvasDerivados A, dbDerivados.dbo.TdParidadMonedasCurvasDescuento B, "
"(SELECT MAX(Fecha) AS FechaMax, Hora, Moneda "
"FROM dbDerivados.dbo.TdCurvasDerivados A, dbDerivados.dbo.TdParidadMonedasCurvasDescuento B "
"WHERE A.Tipo = B.Tipo AND Fecha <= " + fecha_str(self.fechaValores) + " AND Hora = '" + self.hora + "' "
"AND Moneda IN (" + monedas_str + ") GROUP BY Hora, Moneda) C "
"WHERE A.Tipo = B.Tipo AND A.Fecha = C.FechaMax AND A.Hora = C.Hora AND B.Moneda = C.Moneda")
curvas = pd.io.sql.read_sql(curvas, self.cn)
for i in range(len(curvas)):
curva = curvas.Curva.iloc[i]
curvas_monedas[curvas.Moneda[i]] = parsear_curva(curva, self.fechaActual)
if curvas.FechaMax.iloc[i].to_pydatetime().date() < self.fechaValores:
self.set_status("ERROR: valoriza_flujos: Curva para la moneda " + str(curvas.Moneda[i]) +
" no encontrada para la fecha " + str(self.fechaValores) + ". Se utilizó curva de " + str(curvas.FechaMax[i].date()))
send_msg("ERROR: valoriza_flujos: Curva para la moneda " + str(curvas.Moneda[i]) +
" no encontrada para la fecha " + str(self.fechaValores) + ". Se utilizó curva de " + str(curvas.FechaMax[i].date()), self.filename)
error = False
for i in curvas_monedas:
if curvas_monedas[i] == "":
self.set_status("ERROR: valoriza_flujos: No se encontró curva para la moneda " + i +
" en la fecha " + str(self.fechaValores) + " y hora " + self.hora)
send_msg("ERROR: valoriza_flujos: No se encontró curva para la moneda " + i +
" en la fecha " + str(self.fechaValores) + " y hora " + self.hora, self.filename)
error = True
if error:
return
col_flujos_valorizados = ['Fecha', 'Fondo', 'Tipo', 'ID', 'Hora', 'Mercado',
'ActivoPasivo', 'FechaFixing', 'FechaFlujo', 'FechaPago', 'Moneda', 'Flujo',
'Amortizacion', 'Interes', 'MonedaBase', 'PlazoTipoCambioFwd', 'PlazoDescuento',
'TipoCambioSpot', 'TipoCambioFwd', 'FactorDescMonBase', 'FactorDescMonFlujo',
'ValorPresenteMonBase', 'ValorPresenteMonFlujo', 'TipoCambioSpotFix',
'FactorDescMonFlujoFix', 'FactorDescMonBaseFix', 'ValorPresenteCLP',
'TipoCambioCLPBase', 'ValorPresenteUSD', 'TipoCambioUSDBase', 'Sensibilidad',
'TipoValorizacion']
flujos_valorizados = pd.DataFrame(columns=col_flujos_valorizados)
# Por cada flujo, valorizamos
insert = dict()
insert["Fecha"] = self.fechaActual
insert["Tipo"] = self.info_cartera.Tipo.iloc[0]
insert["Hora"] = self.hora
for i in range(len(tabla_aux)):
insert["Fondo"] = tabla_aux.Fondo.iloc[i]
insert["ID"] = tabla_aux.ID.iloc[i]
insert["Mercado"] = tabla_aux.Mercado.iloc[i]
insert["ActivoPasivo"] = tabla_aux.ActivoPasivo.iloc[i]
fecha_fixing = pd.to_datetime(tabla_aux.FechaFixing.iloc[i]).date()
insert["FechaFixing"] = fecha_fixing
fecha_flujo = pd.to_datetime(tabla_aux.FechaFlujo.iloc[i]).date()
insert["FechaFlujo"] = fecha_flujo
fecha_pago = pd.to_datetime(tabla_aux.FechaPago.iloc[i]).date()
insert["FechaPago"] = fecha_pago
moneda = tabla_aux.Moneda.iloc[i]
insert["Moneda"] = moneda
flujo = tabla_aux.Flujo.iloc[i]
insert["Flujo"] = flujo
moneda_base = tabla_aux.MonedaBase.iloc[i]
insert["MonedaBase"] = moneda_base
insert["Amortizacion"] = tabla_aux.Amortizacion.iloc[i]
insert["Interes"] = tabla_aux.Interes.iloc[i]
insert["Sensibilidad"] = tabla_aux.Sensibilidad.iloc[i]
plazo_fixing = (fecha_fixing - self.fechaActual).days
insert["PlazoTipoCambioFwd"] = plazo_fixing
plazo_pago = (fecha_pago - self.fechaActual).days
insert["PlazoDescuento"] = plazo_pago
moneda_c = cast_monedas.get(moneda, moneda)
base_c = cast_monedas.get(moneda_base, moneda_base)
d1 = interpolacion_log_escalar(plazo_pago, curvas_monedas[base_c])
insert["FactorDescMonBase"] = d1
d2 = interpolacion_log_escalar(plazo_fixing, curvas_monedas[moneda_c])
insert["FactorDescMonFlujoFix"] = d2
d3 = interpolacion_log_escalar(plazo_fixing, curvas_monedas[base_c])
insert["FactorDescMonBaseFix"] = d3
insert["ValorPresenteMonFlujo"] = d1 * flujo * (d2 / d3)
# d1/d3 mueve a valor presente desde la fecha pago a la fecha fixing
# d2 trae a valor presente de la fecha fixing a hoy
if plazo_fixing == plazo_pago:
insert["FactorDescMonFlujo"] = d2
else:
insert["FactorDescMonFlujo"] = d2 * (d1 / d3)
flujos_valorizados = flujos_valorizados.append(insert, ignore_index=True)
self.flujos_valorizados = flujos_valorizados.reset_index()
self.set_status("INFO: Valorización completada con éxito")
def genera_flujos(self):
hora = self.hora
cn = self.cn
fechaActual = self.fechaActual
fechaValores = self.fechaValores
fondo = self.info_cartera.Fondo[0]
id = self.info_cartera.ID[0]
fecha_efectiva = pd.to_datetime(
datetime.datetime.strptime(
self.info_cartera.FechaEfectiva[0].split(" ")[0],
"%d/%m/%Y").strftime("%Y-%m-%d")).date()
fecha_venc = pd.to_datetime(
pd.to_datetime(
datetime.datetime.strptime(
self.info_cartera.FechaVenc[0].split(" ")[0],
"%d/%m/%Y").strftime("%Y-%m-%d")).date()).date()
ajuste_feriados = self.info_cartera.AjusteFeriados[0]
paises_feriados = ajuste_feriados.split(',')
moneda = self.info_cartera.MonedaActivo[0]
if self.info_cartera.TipoTasaActivo[0] == 'Fija':
factor_recibo_fijo = 1
tasa = self.info_cartera.TasaActivo[0]
else:
factor_recibo_fijo = -1
tasa = self.info_cartera.TasaPasivo[0]
#tasa = float(tasa.replace(",","."))
nocional = self.info_cartera.NocionalActivo[0]
frecuencia = cast_frecuencia(self.info_cartera.FrecuenciaActivo[0])
if frecuencia == cast_frecuencia("Semi annual"):
convencion = "ACT360"
else:
convencion = "LACT360"
flujos_f = genera_flujos(max(fechaActual,
fecha_efectiva), fecha_efectiva,
fecha_venc, tasa, frecuencia, convencion)
fecha_cupon = flujos_f[0][0]
fecha_aux = delta_frecuencia(fecha_cupon, frecuencia, -1)
fecha_aux = max(fecha_aux, fecha_efectiva)
fecha_cupon_anterior = ultimo_habil_pais(fecha_aux, "CL", cn)
if fechaActual < fecha_cupon_anterior:
vpv = 1
else:
vpv = (
"SELECT ICP1.ICP / ICP0.ICP AS Cupon FROM (SELECT ICP FROM dbAlgebra.dbo.TdIndicadores "
"WHERE (Fecha = " + fecha_str(fechaValores) +
")) ICP1 CROSS JOIN ("
"SELECT ICP FROM dbAlgebra.dbo.TdIndicadores "
"WHERE (Fecha = " + fecha_str(fecha_cupon_anterior) + ")) "
"ICP0")
vpv = pd.io.sql.read_sql(vpv, cn)
vpv = vpv.Cupon[0]
flujos_v = proyectar_flujos_tabla(fechaActual, fechaValores, vpv, hora,
fecha_efectiva, fecha_venc,
frecuencia, moneda, 0, "Local",
ajuste_feriados, cn)
# Simulamos los insert a base de datos
col_flujos_derivados = [
'Fecha', 'Fondo', 'Tipo', 'ID', 'ActivoPasivo', 'FechaFixing',
'FechaFlujo', 'FechaPago', 'Moneda', 'Flujo', 'Amortizacion',
'Interes', 'Sensibilidad', 'InteresDevengado'
]
col_flujos_nosensibles = [
'Fecha', 'Fondo', 'Tipo', 'ID', 'ActivoPasivo',
'FechaFlujoNoSensible', 'Moneda', 'FlujoNoSensible'
]
flujos_derivados = pd.DataFrame(columns=col_flujos_derivados)
flujos_nosensibles = pd.DataFrame(columns=col_flujos_nosensibles)
for i in flujos_v:
flujos_derivados = flujos_derivados.append(
pd.DataFrame([[
fechaActual, fondo, 'SCC', id, -factor_recibo_fijo, i[0],
i[0], i[2], moneda, i[1] / 100 * nocional,
i[3] / 100 * nocional, i[4] / 100 * nocional,
i[5] / 100 * nocional, i[6] / 100 * nocional
]],
columns=col_flujos_derivados))
flujos_nosensibles = flujos_nosensibles.append(
pd.DataFrame([[
fechaActual, fondo, 'SCC', id, -factor_recibo_fijo,
max(fechaActual, fecha_efectiva), moneda, vpv * nocional
]],
columns=col_flujos_nosensibles))
for i in flujos_f:
flujo_fijo = i[1] / 100 * nocional
amortizacion = i[3] / 100 * nocional
interes_fijo = i[4] / 100 * nocional
fecha_flujo_f = i[0]
devengo = i[6] / 100 * nocional
fecha_pago = siguiente_habil_paises(add_days(fecha_flujo_f, -1),
paises_feriados, cn)
test = pd.DataFrame([fecha_flujo_f], columns=["fech"])
flujos_derivados = flujos_derivados.append(
pd.DataFrame([[
fechaActual, fondo, 'SCC', id, factor_recibo_fijo,
fecha_flujo_f, fecha_flujo_f, fecha_pago, moneda,
flujo_fijo, amortizacion, interes_fijo, 0, devengo
]],
columns=col_flujos_derivados))
flujos_nosensibles = flujos_nosensibles.append(
pd.DataFrame([[
fechaActual, fondo, 'SCC', id, factor_recibo_fijo,
fecha_flujo_f, moneda, flujo_fijo
]],
columns=col_flujos_nosensibles))
self.flujos_nosensibles = flujos_nosensibles
self.flujos_derivados = flujos_derivados
self.set_status("INFO: Flujos generados para SCC con ID " +
str(self.info_cartera.ID.iloc[0]))
def genera_flujos(self):
hora = self.hora
cn = self.cn
fecha = self.fecha
fondo = self.info_cartera.Fondo[0]
id = self.info_cartera.ID[0]
fecha_efectiva = pd.to_datetime(self.info_cartera.FechaEfectiva[0]).date()
fecha_venc = pd.to_datetime(self.info_cartera.FechaVenc[0]).date()
ajuste_feriados = self.info_cartera.AjusteFeriados[0]
paises_feriados = ajuste_feriados.split(',')
moneda = self.info_cartera.MonedaActivo[0]
if self.info_cartera.TipoTasaActivo[0] == 'Fija':
factor_recibo_fijo = 1
tasa = self.info_cartera.TasaActivo[0]
else:
factor_recibo_fijo = -1
tasa = self.info_cartera.TasaPasivo[0]
nocional = self.info_cartera.NocionalActivo[0]
frecuencia = self.info_cartera.FrecuenciaActivo[0]
id_key = self.info_cartera.ID_Key[0]
flujos_f = genera_flujos(max(fecha, fecha_efectiva), fecha_efectiva, fecha_venc, tasa, frecuencia, "LACT360")
fecha_cupon = flujos_f[0][0]
fecha_aux = delta_frecuencia(fecha_cupon, frecuencia, -1)
fecha_aux = max(fecha_aux, fecha_efectiva)
fecha_cupon_anterior = ultimo_habil_pais(fecha_aux, "CO", cn)
fecha_aux1 = fecha_str(add_months(max(fecha_efectiva, fecha_cupon_anterior), -1))
fecha_aux2 = fecha_str(add_days(ultimo_habil_pais(max(fecha_efectiva, fecha), "CO", cn), -1))
fecha_aux3 = fecha_str(max(fecha_efectiva, fecha_cupon_anterior))
fecha_aux4 = fecha_str(add_days(ultimo_habil_pais(max(fecha_efectiva, fecha), "CO", cn), -1))
ibr_acum = ("SELECT COALESCE (EXP(SUM(LOG(1 + T.Valor / CAST(36000 as float)))), 1) AS IbrAcum "
"FROM ("
"SELECT MAX(T.Fecha) AS FechaMax, I.Fecha "
"FROM dbAlgebra.dbo.TdTasas T INNER JOIN dbAlgebra.dbo.TdIndicadores I "
"ON T.Fecha <= I.Fecha "
"WHERE T.SiValida = 1 AND T.Hora = 'CIERRE' AND T.Tasa = 'COOVIBR' "
"AND T.Fecha BETWEEN " + fecha_aux1 + " AND " + fecha_aux2 + ""
"AND I.Fecha BETWEEN " + fecha_aux3 + " AND " + fecha_aux4 + ""
"AND T.SiValida = 1 "
"GROUP BY I.Fecha) F "
"INNER JOIN dbAlgebra.dbo.TdTasas T "
"ON F.FechaMax = T.Fecha "
"WHERE T.SiValida = 1 AND T.Hora = 'CIERRE' AND T.Tasa = 'COOVIBR'")
ibr_acum = pd.io.sql.read_sql(ibr_acum, cn)
ibr_acum = ibr_acum.IbrAcum[0]
flujos_v = proyectar_flujos_tabla(fecha, fecha, ibr_acum, hora, fecha_efectiva, fecha_venc, frecuencia, moneda,
0, "Local", ajuste_feriados, cn)
# Simulamos los insert a base de datos
col_flujos_derivados = ['Fecha', 'Fondo', 'Tipo', 'ID', 'ActivoPasivo',
'FechaFixing', 'FechaFlujo', 'FechaPago', 'Moneda', 'Flujo', 'Amortizacion', 'Interes',
'Sensibilidad', 'InteresDevengado', 'Id_Key_Cartera']
col_flujos_nosensibles = ['Fecha', 'Fondo', 'Tipo', 'ID', 'ActivoPasivo',
'FechaFlujoNoSensible', 'Moneda', 'FlujoNoSensible', 'Id_Key_Cartera']
flujos_derivados = pd.DataFrame(columns=col_flujos_derivados)
flujos_nosensibles = pd.DataFrame(columns=col_flujos_nosensibles)
c = 0
for i in flujos_v:
flujos_derivados = flujos_derivados.append(pd.DataFrame([[fecha, fondo, 'IBR', id,
-factor_recibo_fijo, i[0], i[0],
i[2], moneda, i[1]/100*nocional,
i[3]/100 * nocional,
i[4]/100*nocional, i[5] / 100 * nocional,
i[6] / 100 * nocional, id_key]],
columns=col_flujos_derivados))
flujos_nosensibles = flujos_nosensibles.append(pd.DataFrame([[fecha, fondo, 'IBR', id,
-factor_recibo_fijo, max(fecha, fecha_efectiva),
moneda, ibr_acum*nocional, id_key]],
columns=col_flujos_nosensibles))
for i in flujos_f:
flujo_fijo = i[1] / 100 * nocional
amortizacion = i[3] / 100 * nocional
interes_fijo = i[4] / 100 * nocional
fecha_flujo_f = i[0]
devengo = i[6] / 100 * nocional
fecha_pago = siguiente_habil_paises(add_days(fecha_flujo_f, -1), paises_feriados, cn)
flujos_derivados = flujos_derivados.append(pd.DataFrame([[fecha, fondo, 'IBR', id,
factor_recibo_fijo, fecha_flujo_f, fecha_flujo_f,
fecha_pago, moneda, flujo_fijo, amortizacion,
interes_fijo, 0, devengo, id_key]],
columns=col_flujos_derivados))
flujos_nosensibles = flujos_nosensibles.append(pd.DataFrame([[fecha, fondo, 'IBR', id,
factor_recibo_fijo, fecha_flujo_f, moneda,
flujo_fijo, id_key]],
columns=col_flujos_nosensibles))
self.flujos_nosensibles = flujos_nosensibles
self.flujos_derivados = flujos_derivados
self.set_status("INFO: Flujos generados para IBR con ID " + str(self.info_cartera.ID.iloc[0]))
def duplica_fondos_habil_anterior(fecha, servidorApp, instrumentos, empresas,
cn):
"""
Duplica en sector real del servidor las filas con instrumento en el arreglo de instrumentos
:param fecha: datetime.date del proceso
:param servidorApp: String nombre del servidor
:param instrumentos: array de id's de instrumentos para duplicar
:param cn: pyodbc.conection conexión a base de datos
:return: None
"""
instrumentos_excluidos = [
'939', '929', '930', '931', '932', '933', '934', '857', '864', '883',
'884', '885', '886', '887', '891', '894', '896', '899', '919', '924',
'927', '935', '936', '937', '938', '940', '941', '942', '943', '944',
'945', '946', '947', '950', '982', '989', '1025', '1026', '1027',
'1028', '993', '994', '995', '997', '998', '1000', '1001', '1063',
'1047', '1108', '1109', '1110', '1111', '1112', '1113', '1115', '1138',
'1216'
]
instrumentos_excluidos = str(instrumentos_excluidos)[1:-1]
instrumentos = str_condicion(instrumentos, "idInstrumento")
empresas = str_condicion(empresas, "idEmpresa")
sql_servidor = (
"INSERT INTO [" + servidorApp + "].dbSectorReal.dbo.TdDerivadosFondo "
"SELECT idInstrumento, idEmpresa, Visible, '" + fecha_str(fecha) + "' "
"AS Fecha, Fondo, Nombre, Contraparte, Tipo, FechaTransaccion, FechaFixing, FechaEfectiva, FechaVenc, "
"AjusteFeriados, Mercado, Nemotecnico, Referencia, NocionalActivo, MonedaActivo, FrecuenciaActivo, "
"TipoTasaActivo, TasaActivo , SpreadActivo, NocionalPasivo, MonedaPasivo, FrecuenciaPasivo, TipotasaPasivo, "
"TasaPasivo, SpreadPasivo, MonedaBase "
"FROM [" + servidorApp + "].dbSectorReal.dbo.TdDerivadosFondo "
"WHERE " + instrumentos + " OR " + empresas + " "
"AND Fecha=" + fecha_str(ultimo_habil_pais(fecha, 'CL', cn)) +
" AND FechaVenc > " + fecha_str(fecha) + " "
"AND idInstrumento NOT IN (SELECT idInstrumento FROM [" + servidorApp +
"].dbSectorReal.dbo.TdDerivadosFondo "
"WHERE Fecha=" + fecha_str(fecha) + ") AND idInstrumento NOT IN (" +
instrumentos_excluidos + ")")
sql = (
"INSERT INTO dbSectorReal.dbo.TdDerivadosFondo SELECT idInstrumento, idEmpresa, Visible, "
+ fecha_str(fecha) + " "
"AS Fecha, Fondo, Nombre, Contraparte, Tipo, FechaTransaccion, FechaFixing, FechaEfectiva, FechaVenc, "
"AjusteFeriados, Mercado, Nemotecnico, Referencia, NocionalActivo, MonedaActivo, FrecuenciaActivo, "
"TipoTasaActivo, TasaActivo , SpreadActivo, NocionalPasivo, MonedaPasivo, FrecuenciaPasivo, TipotasaPasivo, "
"TasaPasivo, SpreadPasivo, MonedaBase "
"FROM [" + servidorApp + "].dbSectorReal.dbo.TdDerivadosFondo "
"WHERE " + instrumentos + " OR " + empresas + " "
"AND Fecha=" + fecha_str(ultimo_habil_pais(fecha, 'CL', cn)) + " "
"AND FechaVenc > " + fecha_str(fecha) + " "
"AND idInstrumento NOT IN (SELECT idInstrumento "
"FROM [" + servidorApp + "].dbSectorReal.dbo.TdDerivadosFondo "
"WHERE Fecha=" + fecha_str(fecha) + ") "
"AND idInstrumento NOT IN (" + instrumentos_excluidos + ")")
cursor = cn.cursor()
cursor.execute(sql)
cursor.execute(sql_servidor)
send_msg("") # todo
def genera_flujos(self):
hora = self.hora
cn = self.cn
fecha = self.fecha
admin = self.info_cartera.Administradora[0]
fondo = self.info_cartera.Fondo[0]
contraparte = self.info_cartera.Contraparte[0]
id = self.info_cartera.ID[0]
fecha_efectiva = pd.to_datetime(self.info_cartera.FechaEfectiva[0]).date()
fecha_venc = pd.to_datetime(self.info_cartera.FechaVenc[0]).date()
ajuste_feriados = self.info_cartera.AjusteFeriados[0]
paises_feriados = ajuste_feriados.split(',')
moneda = self.info_cartera.MonedaActivo[0]
if self.info_cartera.TipoTasaActivo[0] == 'Fija':
factor_recibo_fijo = 1
tasa = self.info_cartera.TasaActivo[0]
else:
factor_recibo_fijo = -1
tasa = self.info_cartera.TasaPasivo[0]
nocional = self.info_cartera.NocionalActivo[0]
frecuencia = cast_frecuencia(self.info_cartera.FrecuenciaActivo[0])
id_key = self.info_cartera.ID_Key[0]
convencion = "LACT360"
flujos_f = genera_flujos(max(fecha, fecha_efectiva), fecha_efectiva, fecha_venc, tasa, frecuencia, convencion)
fecha_cupon = flujos_f[0][0]
fecha_aux = delta_frecuencia(fecha_cupon, frecuencia, -1)
fecha_aux = max(fecha_aux, fecha_efectiva)
fecha_cupon_anterior = ultimo_habil_pais(fecha_aux, "CL", cn)
if fecha < fecha_cupon_anterior:
vpv = 1
else:
vpv = ("SELECT (ICP1.ICP / ICP0.ICP)/(ICP1.UF / ICP0.UF) AS Cupon FROM "
"(SELECT ICP, UF FROM dbAlgebra.dbo.TdIndicadores "
"WHERE (Fecha = " + fecha_str(fecha) + ")) ICP1 CROSS JOIN ("
"SELECT ICP, UF FROM dbAlgebra.dbo.TdIndicadores "
"WHERE (Fecha = " + fecha_str(fecha_cupon_anterior) + ")) "
"ICP0")
vpv = pd.io.sql.read_sql(vpv, cn)
vpv = vpv.Cupon[0]
flujos_v = proyectar_flujos_tabla(fecha, fecha, vpv, hora, fecha_efectiva, fecha_venc, frecuencia, moneda, 0,
"Local", ajuste_feriados, cn)
# Simulamos los insert a base de datos
col_flujos_derivados = ['Fecha', 'Administradora', 'Fondo', 'Contraparte', 'Tipo', 'ID', 'ActivoPasivo',
'FechaFixing', 'FechaFlujo', 'FechaPago', 'Moneda', 'Flujo', 'Amortizacion', 'Interes',
'Sensibilidad', 'InteresDevengado', 'Id_Key_Cartera']
col_flujos_nosensibles = ['Fecha', 'Administradora', 'Fondo', 'Contraparte', 'Tipo', 'ID', 'ActivoPasivo',
'FechaFlujoNoSensible', 'Moneda', 'FlujoNoSensible', 'Id_Key_Cartera']
flujos_derivados = pd.DataFrame(columns=col_flujos_derivados)
flujos_nosensibles = pd.DataFrame(columns=col_flujos_nosensibles)
for i in flujos_v:
flujos_derivados = flujos_derivados.append(pd.DataFrame([[fecha, admin, fondo, contraparte, 'SUC', id,
-factor_recibo_fijo, i[0], i[0],
i[2], moneda, i[1] / 100 * nocional,
i[3] / 100 * nocional,
i[4] / 100 * nocional, i[5] / 100 * nocional,
i[6] / 100 * nocional, id_key]],
columns=col_flujos_derivados))
flujos_nosensibles = flujos_nosensibles.append(pd.DataFrame([[fecha, admin, fondo, contraparte, 'SUC', id,
-factor_recibo_fijo, max(fecha, fecha_efectiva),
moneda,
vpv * nocional, id_key]],
columns=col_flujos_nosensibles))
for i in flujos_f:
flujo_fijo = i[1] / 100 * nocional
amortizacion = i[3] / 100 * nocional
interes_fijo = i[4] / 100 * nocional
fecha_flujo_f = i[0]
devengo = i[6] / 100 * nocional
fecha_pago = siguiente_habil_paises(add_days(fecha_flujo_f, -1), paises_feriados, cn)
flujos_derivados = flujos_derivados.append(pd.DataFrame([[fecha, admin, fondo, contraparte, 'SUC', id,
factor_recibo_fijo, fecha_flujo_f, fecha_flujo_f,
fecha_pago, moneda, flujo_fijo, amortizacion,
interes_fijo, 0, devengo, id_key]],
columns=col_flujos_derivados))
flujos_nosensibles = flujos_nosensibles.append(pd.DataFrame([[fecha, admin, fondo, contraparte, 'SUC', id,
factor_recibo_fijo, fecha_flujo_f, moneda,
flujo_fijo, id_key]],
columns=col_flujos_nosensibles))
self.flujos_nosensibles = flujos_nosensibles
self.flujos_derivados = flujos_derivados
self.set_status("INFO: Flujos generados para SUC con ID " + str(self.info_cartera.ID.iloc[0]))
