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]))