def mtm_titpublico():
import datetime
import pandas as pd
import numpy as np
import pymysql as db
import logging
from findt import FinDt
from dependencias.Metodos.funcoes_auxiliares import full_path_from_database
from dependencias.Metodos.funcoes_auxiliares import get_data_ultimo_dia_util_mes_anterior
logger = logging.getLogger(__name__)
# Diretório de save de planilhas
save_path = full_path_from_database('mtm_titpublico_output') + 'erro.xlsx'
feriados_sheet = full_path_from_database('feriados_nacionais') + 'feriados_nacionais.csv'
# Pega a data do último dia útil do mês anterior e deixa no formato específico para utilização da função
dtbase = get_data_ultimo_dia_util_mes_anterior()
#dtbase = ['2016','11','30']
dt_base = dtbase[0] + '-' + dtbase[1] + '-' + dtbase[2]
# Data formatada como Dia-Mes-Ano
data_inicio = dtbase[2] + '-' + dtbase[1] + '-' + dtbase[0]
# Conexão com Banco de Dados
logger.info("Conectando no Banco de dados")
connection = db.connect('localhost', user='******', passwd='root', db='projeto_inv'
, use_unicode=True, charset="utf8")
logger.info("Conexão com DB executada com sucesso")
query = 'SELECT a.* FROM projeto_inv.anbima_tpf a right join (select dt_referencia, max(dt_carga) as dt_carga from projeto_inv.anbima_tpf where dt_referencia="' + dt_base + '" group by 1) b on a.dt_referencia=b.dt_referencia and a.dt_carga=b.dt_carga;'
basetaxa = pd.read_sql(query, con=connection)
logger.info("Leitura do banco de dados executada com sucesso")
basetaxa = basetaxa.reset_index(level=None, drop=False, inplace=False, col_level=0, col_fill='')
basetaxa1 = basetaxa[["titulo", "cod_selic", "dt_emissao", "dt_vencto", "dt_referencia", "tx_indicativa", "pu"]]
query = 'SELECT a.* FROM projeto_inv.anbima_fluxo_tpf a right join (select titulo, cod_selic, dt_emissao, dt_vencto, max(data_bd) as data_bd from projeto_inv.anbima_fluxo_tpf group by 1,2,3,4) b on a.titulo=b.titulo and a.cod_selic=b.cod_selic and a.dt_emissao=b.dt_emissao and a.dt_vencto=b.dt_vencto and a.data_bd=b.data_bd;'
baseref1 = pd.read_sql(query, con=connection)
logger.info("Leitura do banco de dados executada com sucesso")
logger.info("Tratando dados")
baseref1 = pd.merge(baseref1, basetaxa1, left_on=['titulo', 'cod_selic', 'dt_emissao', 'dt_vencto'],
right_on=['titulo', 'cod_selic', 'dt_emissao', 'dt_vencto'], how='right')
baseref2 = baseref1.reindex(
columns=['titulo', 'cod_selic', 'dt_emissao', 'dt_vencto', 'dt_vencto2', 'tx_indicativa', 'dt_referencia', 'cupom',
'dt_ref', 'fv'])
anbima_fluxomtm_tpf = baseref2[baseref2['dt_ref'] >= baseref2['dt_referencia']].copy()
dt_max = max(anbima_fluxomtm_tpf['dt_ref'])
dt_max = dt_max.strftime('%d-%m-%Y')
per = FinDt.DatasFinanceiras(data_inicio, dt_max, path_arquivo = feriados_sheet)
du = pd.DataFrame(columns=['dt_ref'])
dc = pd.DataFrame(columns=['dt_ref'])
dc['dt_ref'] = per.dias()
du['dt_ref'] = per.dias(3)
du['flag_du'] = 1
controle_du = pd.merge(dc, du, left_on=['dt_ref'], right_on=['dt_ref'], how='left')
controle_du = controle_du.fillna(0)
controle_du['du'] = np.cumsum(controle_du['flag_du']).astype(float)
anbima_fluxomtm_tpf = pd.merge(anbima_fluxomtm_tpf, controle_du, left_on=['dt_ref'], right_on=['dt_ref'], how='left')
dt_base1 = dt_base + ' 00:00:00'
query = 'select a.codigo_selic, a.titulo, a.vna from projeto_inv.anbima_vna a right join (select titulo, codigo_selic, data_referencia, max(data_bd) as data_bd from projeto_inv.anbima_vna where data_referencia="' + dt_base1 + '" group by 1,2,3) b on a.titulo=b.titulo and a.codigo_selic=b.codigo_selic and a.data_referencia=b.data_referencia and a.data_bd=b.data_bd;'
vna = pd.read_sql(query, con=connection)
logger.info("Leitura do banco de dados executada com sucesso")
anbima_fluxomtm_tpf['titulo'] = np.where(anbima_fluxomtm_tpf['titulo'] == 'LFT', 'lft', anbima_fluxomtm_tpf['titulo'])
anbima_fluxomtm_tpf['titulo'] = np.where(anbima_fluxomtm_tpf['titulo'] == 'LTN', 'ltn', anbima_fluxomtm_tpf['titulo'])
anbima_fluxomtm_tpf['titulo'] = np.where(anbima_fluxomtm_tpf['titulo'] == 'NTN-F', 'ntnf',
anbima_fluxomtm_tpf['titulo'])
anbima_fluxomtm_tpf['titulo'] = np.where(anbima_fluxomtm_tpf['titulo'] == 'NTN-C', 'ntnc',
anbima_fluxomtm_tpf['titulo'])
anbima_fluxomtm_tpf['titulo'] = np.where(anbima_fluxomtm_tpf['titulo'] == 'NTN-B', 'ntnb',
anbima_fluxomtm_tpf['titulo'])
anbima_fluxomtm_tpf['cotacao'] = 0
anbima_fluxomtm_tpf['fv1'] = 0
anbima_fluxomtm_tpf['pv'] = 0
anbima_fluxomtm_tpf = pd.merge(anbima_fluxomtm_tpf, vna, left_on=['cod_selic', 'titulo'],
right_on=['codigo_selic', 'titulo'], how='left')
del anbima_fluxomtm_tpf['codigo_selic']
anbima_fluxomtm_tpf.ix[anbima_fluxomtm_tpf.titulo == 'ltn', 'vna'] = 1000
anbima_fluxomtm_tpf.ix[anbima_fluxomtm_tpf.titulo == 'ntnf', 'vna'] = 1000
anbima_fluxomtm_tpf1 = anbima_fluxomtm_tpf.copy()
anbima_fluxomtm_tpf = anbima_fluxomtm_tpf1.copy()
anbima_fluxomtm_tpf['dif'] = (pd.to_datetime(anbima_fluxomtm_tpf['dt_vencto2']) - pd.to_datetime(
anbima_fluxomtm_tpf['dt_ref'])).astype('timedelta64[D]') * 1
anbima_fluxomtm_tpf['fv'] = np.where(anbima_fluxomtm_tpf.dif <= 10.0, (1 + (anbima_fluxomtm_tpf['cupom'])) ** 0.5,
(1 + (anbima_fluxomtm_tpf['cupom'])) ** 0.5 - 1)
anbima_fluxomtm_tpf.ix[anbima_fluxomtm_tpf.titulo == 'ltn', 'fv'] = 1
anbima_fluxomtm_tpf.ix[anbima_fluxomtm_tpf.titulo == 'lft', 'fv'] = 1
del anbima_fluxomtm_tpf['dif']
anbima_fluxomtm_tpf['du_ajustado'] = np.where(anbima_fluxomtm_tpf['dt_vencto2'] == anbima_fluxomtm_tpf['dt_ref'],
anbima_fluxomtm_tpf['du'],
anbima_fluxomtm_tpf['du'] + anbima_fluxomtm_tpf['flag_du'])
titpublico = pd.DataFrame()
ltn = anbima_fluxomtm_tpf[anbima_fluxomtm_tpf['titulo'] == 'ltn'].copy()
formcor = np.float64((ltn['vna'] * ltn['fv'] / ((1 + ltn['tx_indicativa'] / 100) ** (ltn['du'] / 252))))
ltn['pv'] = np.trunc(formcor * (10 ** 6)) / (10 ** 6)
titpublico = titpublico.append(ltn)
lft = anbima_fluxomtm_tpf[anbima_fluxomtm_tpf['titulo'] == 'lft'].copy()
lft['cotacao'] = np.trunc(1 / (1 + lft['tx_indicativa'] / 100) ** (lft['du'] / 252) * (10 ** 6)) / (10 ** 6)
formcor = np.float64(lft['vna'] * lft['cotacao'] * (10 ** 6))
lft['pv'] = np.trunc(formcor) / (10 ** 6)
titpublico = titpublico.append(lft)
ntnf = anbima_fluxomtm_tpf[anbima_fluxomtm_tpf['titulo'] == 'ntnf'].copy()
formcor = np.float64(ntnf['fv'] * ntnf['vna'] * (10 ** 9))
ntnf['fv1'] = np.trunc(formcor) / (10 ** 9)
ntnf['pv'] = np.trunc((ntnf['fv1'] / (1 + ntnf['tx_indicativa'] / 100) ** (ntnf['du'] / 252)) * (10 ** 7)) / (10 ** 7)
titpublico = titpublico.append(ntnf)
ntnc = anbima_fluxomtm_tpf[anbima_fluxomtm_tpf['titulo'] == 'ntnc'].copy()
formcor = np.float64(
(np.trunc((ntnc['fv'] / (1 + ntnc['tx_indicativa'] / 100) ** (ntnc['du'] / 252)) * (10 ** 8)) / (10 ** 8)) * ntnc[
'vna'] * (10 ** 6))
ntnc['pv'] = np.trunc(formcor) / (10 ** 6)
titpublico = titpublico.append(ntnc)
ntnb = anbima_fluxomtm_tpf[anbima_fluxomtm_tpf['titulo'] == 'ntnb'].copy()
formcor = np.float64(
(np.trunc((ntnb['fv'] / (1 + ntnb['tx_indicativa'] / 100) ** (ntnb['du'] / 252)) * (10 ** 8)) / (10 ** 8)) * ntnb[
'vna'] * (10 ** 6))
ntnb['pv'] = np.trunc(formcor) / (10 ** 6)
titpublico = titpublico.append(ntnb)
del titpublico['cotacao']
del titpublico['fv1']
mtm_sum_tpf = titpublico.groupby(["titulo", "dt_vencto"], as_index=False).sum()
mtm_sum_tpf.rename(columns={'pv': 'pu_calc'}, inplace=True)
anbima_mtm_sum_tpf = mtm_sum_tpf[["titulo", "dt_vencto", "pu_calc"]]
anbima_fluxomtm_tpf = pd.merge(titpublico, anbima_mtm_sum_tpf, left_on=["titulo", "dt_vencto"],
right_on=["titulo", "dt_vencto"], how='left')
anbima_fluxomtm_tpf['perc_pu_fluxo'] = anbima_fluxomtm_tpf['pv'] / anbima_fluxomtm_tpf['pu_calc']
anbima_fluxomtm_tpf['data_bd'] = datetime.datetime.today()
# Salvar no MySQL
logger.info("Salvando base de dados - anbima_fluxomtm_tpf")
pd.io.sql.to_sql(anbima_fluxomtm_tpf, name='anbima_fluxomtm_tpf', con=connection, if_exists='append', flavor='mysql',
index=0)
connection.close()
# validacao
basetaxa1['titulo'] = np.where(basetaxa1['titulo'] == 'LFT', 'lft', basetaxa1['titulo'])
basetaxa1['titulo'] = np.where(basetaxa1['titulo'] == 'LTN', 'ltn', basetaxa1['titulo'])
basetaxa1['titulo'] = np.where(basetaxa1['titulo'] == 'NTN-F', 'ntnf', basetaxa1['titulo'])
basetaxa1['titulo'] = np.where(basetaxa1['titulo'] == 'NTN-C', 'ntnc', basetaxa1['titulo'])
basetaxa1['titulo'] = np.where(basetaxa1['titulo'] == 'NTN-B', 'ntnb', basetaxa1['titulo'])
anbima_mtm_sum_tpf = anbima_mtm_sum_tpf.merge(basetaxa1, on=['titulo', 'dt_vencto'], how='left')
anbima_mtm_sum_tpf['erro'] = anbima_mtm_sum_tpf['pu'] - anbima_mtm_sum_tpf['pu_calc']
anbima_mtm_sum_tpf.to_excel(save_path, sheet_name='titpublico')
logger.info("Arquivos salvos com sucesso")
def simulacao_credito():
import pandas as pd
import pymysql as db
import numpy as np
import math
import logging
from dependencias.Metodos.funcoes_auxiliares import get_global_var
from dependencias.Metodos.funcoes_auxiliares import get_data_ultimo_dia_util_mes_anterior
from dependencias.Metodos.funcoes_auxiliares import full_path_from_database
from findt import FinDt
feriados_sheet = full_path_from_database(
'feriados_nacionais') + 'feriados_nacionais.csv'
cnpj_hdi = get_global_var("cnpj_hdi")
logger = logging.getLogger(__name__)
dt_base = get_data_ultimo_dia_util_mes_anterior()
dt_base = dt_base[0] + '-' + dt_base[1] + '-' + dt_base[2]
#qtde_simulacao = 3000
qtde_simulacao = 1
logger.info("Conectando no Banco de dados")
connection = db.connect('localhost',
user='******',
passwd='root',
db='projeto_inv',
use_unicode=True,
charset="utf8")
logger.info("Conexão com DB executada com sucesso")
query = 'select distinct nome_emissor, cnpj_emissor, data_criacao_emissor from projeto_inv.bmf_emissor where cnpj_emissor>0;'
emissor = pd.read_sql(query, con=connection)
logger.info("Leitura do banco de dados executada com sucesso")
#Fecha conexão
connection.close()
emissor = emissor.sort(['cnpj_emissor', 'data_criacao_emissor'],
ascending=[True, False])
emissor1 = emissor.drop_duplicates(subset=['cnpj_emissor'],
take_last=False)
emissor1['cnpj'] = emissor1['cnpj_emissor'].astype(float)
emissor1 = emissor1.rename(columns={'nome_emissor': 'contraparte'})
emissor2 = emissor1[['cnpj', 'contraparte']]
#seleção da carteira
def quadro_oper(dt_base, cnpj):
#Global Variables:
global start
global header_id_carteira
global quadro_oper
global tp
global tp_expo
global tp_fluxo
global id_relatorio_qo
start = dt_base
logger.info("Conectando no Bancode dados")
connection = db.connect('localhost',
user='******',
passwd='root',
db='projeto_inv',
use_unicode=True,
charset="utf8")
logger.info("Conexão com DB executada com sucesso")
query = 'select * from projeto_inv.xml_header_org where cnpjcpf="' + cnpj + '" and dtposicao=' + '"' + dt_base + '";'
df = pd.read_sql(query, con=connection)
if len(df) == 0:
query = 'select * from projeto_inv.xml_header_org where cnpj="' + cnpj + '" and dtposicao=' + '"' + dt_base + '";'
df = pd.read_sql(query, con=connection)
df = df.sort(['cnpj', 'cnpjcpf', 'data_bd'],
ascending=[True, True, False])
df = df.drop_duplicates(subset=['cnpj', 'cnpjcpf'], take_last=False)
df = df.reset_index(level=None,
drop=False,
inplace=False,
col_level=0,
col_fill='')
del df['index']
header_id_carteira = df.get_value(0, 'header_id').astype(str)
# quadro de operaçao
query = 'select a.* from projeto_inv.xml_quadro_operacoes a right join (select header_id, max(data_bd) as data_bd from projeto_inv.xml_quadro_operacoes where header_id=' + header_id_carteira + ' group by 1) b on a.header_id=b.header_id and a.data_bd=b.data_bd;'
quadro_oper = pd.read_sql(query, con=connection)
logger.info("Leitura do banco de dados executada com sucesso")
tp = quadro_oper.loc[quadro_oper['produto'].isin(
['título privado', 'debênture'])]
id_relatorio_qo = tp['id_relatorio_qo'][0]
# fidc
fundos = quadro_oper.loc[quadro_oper['produto'].isin(['fundo'])].copy()
fundos['fundo_final'] = np.where(fundos['fundo_ult_nivel'].isnull(),
fundos['fundo'],
fundos['fundo_ult_nivel'])
#INCLUIR FIDCS
fidc = fundos[fundos['fundo_final'].str.contains(
'FIDC|DIREITOS|CREDITÓRIO|CREDITORIOS|DIREITOS')]
tp = tp.append(fidc)
tp['contraparte'] = np.where(tp.produto == 'fundo', tp.fundo_final,
tp.contraparte)
tp['cnpj_fundo_final'] = np.where(
(tp.produto == 'fundo') & (tp.cnpjfundo_outros.isnull()),
tp.cnpjfundo_1nivel, tp.cnpjfundo_outros)
tp['cnpj'] = np.where(tp.produto == 'fundo', tp.cnpj_fundo_final,
tp.cnpj)
# pegar exposicao mercado
tp['expo_final'] = np.where(tp['caracteristica'] != 'N',
tp['pu_mercado'] * tp['quantidade'],
tp['mtm_info'])
tp['expo_final'] = np.where(tp['expo_final'] == 0, tp['mtm_info'],
tp['expo_final'])
tp['expo_final'] = np.where(tp.produto == 'fundo', tp['mtm_info'],
tp['expo_final'])
# incluir data de vencimento de fidc
query = 'select distinct codigo_isin, dtvencimento, data_bd, max(data_ref) as dt_ref from projeto_inv.mtm_renda_fixa group by 1,2,3; '
dfvencto = pd.read_sql(query, con=connection)
dfvencto = dfvencto.sort_values(by=['codigo_isin', 'data_bd'],
ascending=[True, False])
dfvencto1 = dfvencto.drop_duplicates(subset=['codigo_isin'],
take_last=False)
dfvencto1['dt_vencto_fim'] = np.where(dfvencto1.dtvencimento.isnull(),
dfvencto1.dt_ref,
dfvencto1.dtvencimento)
base_vencto = dfvencto1[['codigo_isin', 'dt_vencto_fim']].copy()
tp = pd.merge(tp,
base_vencto,
left_on='isin',
right_on='codigo_isin',
how='left')
tp['dt_vencto_1'] = np.where(tp.dt_vencto.isnull(), tp.dt_vencto_fim,
tp.dt_vencto)
del tp['codigo_isin']
del tp['dt_vencto']
del tp['dt_vencto_fim']
tp = tp.rename(columns={'dt_vencto_1': 'dt_vencto'})
tp_mtm = tp[[
'expo_final', 'quantidade', 'isin', 'cnpj', 'produto', 'dt_vencto',
'fundo_final'
]].copy()
tp_mtm = pd.merge(tp_mtm,
emissor2,
left_on='cnpj',
right_on='cnpj',
how='left')
tp_mtm['contraparte'] = tp_mtm['contraparte'].fillna(
tp_mtm['fundo_final'])
del tp_mtm['fundo_final']
tp_expo = tp_mtm.groupby(
['isin', 'cnpj', 'contraparte', 'produto', 'dt_vencto'],
as_index=False).sum()
tp_expo = tp_expo.reset_index(level=None,
drop=False,
inplace=False,
col_level=0,
col_fill='')
tp_expo['cnpj'] = tp_expo['cnpj'].astype(float)
tp_expo['cnpj1'] = ""
for i in range(0, len(tp_expo)):
if tp_expo['cnpj'][i] > 0:
tp_expo['cnpj1'][i] = math.floor(tp_expo['cnpj'][i])
#i=i+1
tp_expo['cnpj2'] = tp_expo['cnpj1'].astype(str).str.zfill(14)
del tp_expo['cnpj']
del tp_expo['cnpj1']
tp_expo = tp_expo.rename(columns={'cnpj2': 'cnpj'})
# fluxos
query = 'select a.codigo_isin, a.fv, a.data_ref, a.indexador, a.data_mtm, a.data_bd from projeto_inv.mtm_renda_fixa a right join (select codigo_isin, data_mtm, max(data_bd) as data_bd from projeto_inv.mtm_renda_fixa where data_mtm="' + dt_base + '" group by 1,2) b on a.codigo_isin=b.codigo_isin and a.data_mtm=b.data_mtm and a.data_bd=b.data_bd;'
fluxos = pd.read_sql(query, con=connection)
tp_fluxo = pd.merge(tp_expo,
fluxos,
left_on='isin',
right_on='codigo_isin')
del tp_fluxo['data_bd']
tp_fluxo['fv1'] = abs(tp_fluxo['fv'] * tp_fluxo['quantidade'])
del tp_fluxo['fv']
tp_fluxo = tp_fluxo.rename(columns={'fv1': 'fv'})
del tp_fluxo['codigo_isin']
tp_fluxo = tp_fluxo.reindex(
columns=['isin', 'data_ref', 'indexador', 'fv'])
#Fecha conexão
connection.close()
quadro_oper(dt_base, cnpj_hdi)
fluxo_original = tp_fluxo.copy()
logger.info("Conectando no Banco de dados")
connection = db.connect('localhost',
user='******',
passwd='root',
db='projeto_inv',
use_unicode=True,
charset="utf8")
logger.info("Conexão com DB executada com sucesso")
# LGD
query = 'select a.produto, a.lgd from projeto_inv.lgd a right join (select produto, max(data_bd) as data_bd from projeto_inv.lgd group by 1) b on a.produto=b.produto and a.data_bd=b.data_bd;'
lgd = pd.read_sql(query, con=connection)
#simulação de cenário____________________________________________________________________________
query = 'SELECT n.* FROM projeto_inv.curva_ettj_interpol n INNER JOIN ( SELECT indexador_cod, month(dt_ref ) as mes, year (dt_ref) as ano, max(dt_ref) as max FROM projeto_inv.curva_ettj_interpol GROUP BY 1,2,3) a on a.indexador_cod=n.indexador_cod and a.max=n.dt_ref;'
cen = pd.read_sql(query, con=connection)
cen = cen.sort(['indexador_cod', 'prazo', 'dt_ref', 'data_bd'],
ascending=[True, True, True, False])
cen1 = cen.drop_duplicates(subset=['indexador_cod', 'prazo', 'dt_ref'],
take_last=False)
cen1['indexador_shift'] = cen1['indexador_cod'].shift()
cen1['prazo_shift'] = cen1['prazo'].shift()
cen1['tx_spot_shift'] = cen1['tx_spot'].shift()
cen1['dif'] = np.where((cen1.indexador_cod == cen1.indexador_shift) &
(cen1.prazo == cen1.prazo_shift),
cen1.tx_spot - cen1.tx_spot_shift, 'NaN')
cen2 = cen1[cen1.dif != 'NaN']
#________________________________________________________________________________________________________
# GERACAO DE SERIE DE DIAS ÚTEIS E DIAS CORRIDOS
ano = start[0:4]
mes = start[5:7]
dia = start[8:10]
dt_inicio = dia + '-' + mes + '-' + ano
dt_max = max(tp_expo['dt_vencto'])
per = FinDt.DatasFinanceiras(dt_inicio,
dt_max,
path_arquivo=feriados_sheet)
du = pd.DataFrame(columns=['data_ref'])
dc = pd.DataFrame(columns=['data_ref'])
dc['data_ref'] = per.dias()
dc['flag_dc'] = 1
du['data_ref'] = per.dias(3)
du['flag_du'] = 1
serie_dias = pd.merge(dc,
du,
left_on=['data_ref'],
right_on=['data_ref'],
how='left')
serie_dias['flag_du'] = serie_dias['flag_du'].fillna(0)
serie_dias['indice_dc'] = np.cumsum(serie_dias['flag_dc'])
serie_dias['indice_du'] = np.cumsum(serie_dias['flag_du'])
del serie_dias['flag_du']
del serie_dias['flag_dc']
# OBS: a contagem de dias é o valor do índice menos um
#PD e matriz de migracao________________________________
query = "select * from projeto_inv.pd_mes;"
pd_mes = pd.read_sql(query, con=connection)
pd_mes = pd_mes.sort(['rtg', 'produto', 'prazo', 'data_bd'],
ascending=[True, True, True, False])
pd_mes = pd_mes.drop_duplicates(subset=['rtg', 'produto', 'prazo'],
take_last=False)
query = "select * from projeto_inv.matriz_migr_mes;"
matriz_mes = pd.read_sql(query, con=connection)
matriz_mes = matriz_mes.sort(['cod_rtg_de', 'cod_rtg_para', 'data_bd'],
ascending=[True, True, False])
matriz_mes = matriz_mes.drop_duplicates(
subset=['cod_rtg_de', 'cod_rtg_para'], take_last=False)
#TIPO DE PAPEL
query = "select distinct codigo_isin, data_bd, tipo_ativo from projeto_inv.bmf_numeraca where tipo_ativo in ('DBS', 'LFI', 'LFN', 'DP', 'C', 'CC','CCC', 'CRI');"
caracteristica = pd.read_sql(query, con=connection)
caracteristica = caracteristica.sort(['codigo_isin', 'data_bd'],
ascending=[True, False])
caracteristica = caracteristica.drop_duplicates(subset=['codigo_isin'],
take_last=False)
del caracteristica['data_bd']
df_original = pd.merge(tp_expo,
caracteristica,
left_on='isin',
right_on='codigo_isin',
how='left')
df_original.ix[df_original.tipo_ativo == 'CC', 'tipo_pd'] = 'ccb'
df_original.ix[df_original.tipo_ativo == 'CCC', 'tipo_pd'] = 'ccb'
df_original.ix[df_original.tipo_ativo == 'DBS', 'tipo_pd'] = 'deb'
df_original.ix[df_original.tipo_ativo == 'C', 'tipo_pd'] = 'cdb'
df_original.ix[df_original.tipo_ativo == 'LFI', 'tipo_pd'] = 'cdb'
df_original.ix[df_original.tipo_ativo == 'LFN', 'tipo_pd'] = 'cdb'
df_original.ix[df_original.tipo_ativo == 'DP', 'tipo_pd'] = 'cdb'
df_original['tipo_pd'] = df_original['tipo_pd'].fillna('fidc')
del df_original['codigo_isin']
#RATING________________________________
query = 'select cod_rtg, rtg from projeto_inv.de_para_rtg a right join (select max(data_bd) as data_bd from projeto_inv.de_para_rtg) b on a.data_bd = b.data_bd;'
depara = pd.read_sql(query, con=connection)
#regua mestra
query = 'select distinct a.cod_rtg, a.agencia_rtg, a.rtg from projeto_inv.de_para_rtg a right join (select agencia_rtg, max(data_bd) as data_bd from projeto_inv.de_para_rtg where agencia_rtg="regua" group by 1) b on a.agencia_rtg=b.agencia_rtg and a.data_bd = b.data_bd;'
regua_rtg = pd.read_sql(query, con=connection)
del regua_rtg['agencia_rtg']
#rating por isin
query = 'select distinct a.isin, a.agencia_tipo_rtg, a.rtg from projeto_inv.rating_isin as a right join (select max(data_bd) as data_bd from projeto_inv.rating_isin where dt_ref= "' + dt_base + '" ) as b on a.data_bd=b.data_bd;'
rtg_isin = pd.read_sql(query, con=connection)
rtg_local = rtg_isin.loc[rtg_isin['agencia_tipo_rtg'].isin([
'RTG_MDY_NSR', 'RTG_MDY_NSR_SR_UNSECURED', 'RTG_MDY_NSR_SUBORDINATED',
'RTG_SP_NATIONAL', 'RTG_FITCH_NATIONAL_LT', 'RTG_FITCH_NATIONAL',
'RTG_FITCH_NATIONAL_SR_UNSECURED', 'RTG_FITCH_NATL_SUBORDINATED'
])]
rtg_local = pd.merge(rtg_local,
depara,
left_on='rtg',
right_on='rtg',
how='left')
rtg_pior = rtg_local[['isin', 'cod_rtg']].copy()
rtg_pior = rtg_pior.groupby(['isin'], as_index=False).max()
rtg_pior = pd.merge(rtg_pior,
regua_rtg,
left_on='cod_rtg',
right_on='cod_rtg',
how='left')
#rating por contraparte
query = 'select distinct a.cnpj, a.agencia_tipo_rtg, a.rtg from projeto_inv.rating_contraparte as a right join (select max(data_bd) as data_bd from projeto_inv.rating_contraparte where dt_ref= "' + dt_base + '" ) as b on a.data_bd=b.data_bd;'
rtg_c = pd.read_sql(query, con=connection)
rtg_c_local = rtg_c.loc[rtg_c['agencia_tipo_rtg'].isin([
'RTG_MDY_NSR_ISSUER', 'RTG_SP_NATIONAL_LT_ISSUER_CREDIT',
'RTG_FITCH_NATIONAL_LT', 'RTG_FITCH_NATIONAL_SR_UNSECURED'
])]
rtg_c_local = pd.merge(rtg_c_local,
depara,
left_on='rtg',
right_on='rtg',
how='left')
rtg_c_pior = rtg_c_local[['cnpj', 'cod_rtg']].copy()
rtg_c_pior = rtg_c_pior.groupby(['cnpj'], as_index=False).max()
rtg_c_pior = pd.merge(rtg_c_pior,
regua_rtg,
left_on='cod_rtg',
right_on='cod_rtg',
how='left')
#agregar o rtg na base
df_original = pd.merge(df_original,
rtg_pior,
left_on='isin',
right_on='isin',
how='left')
df_original = df_original.rename(columns={
'cod_rtg': 'cod_rtg_isin',
'rtg': 'rtg_isin'
})
df_original = pd.merge(df_original,
rtg_c_pior,
left_on='cnpj',
right_on='cnpj',
how='left')
df_original = df_original.rename(columns={
'cod_rtg': 'cod_rtg_cnpj',
'rtg': 'rtg_cnpj'
})
df_original['cod_rtg'] = np.where(df_original['cod_rtg_isin'].isnull(),
df_original.cod_rtg_cnpj,
df_original.cod_rtg_isin)
del df_original['cod_rtg_isin']
del df_original['cod_rtg_cnpj']
del df_original['rtg_isin']
del df_original['rtg_cnpj']
df_original = pd.merge(df_original,
regua_rtg,
left_on='cod_rtg',
right_on='cod_rtg',
how='left')
#assumir rtg padrão missing: 'Aa3' e cod_rtg=4
df_original['cod_rtg'] = df_original['cod_rtg'].fillna(3)
df_original['rtg'] = df_original['rtg'].fillna('Aa2')
df_original = df_original.rename(columns={'rtg': 'rating'})
#Fecha conexão
connection.close()
#inicio da simulacao
def simulacao(id_simulacao):
global df
global fluxo
global df_resultado
global i_tempo
df = df_original.copy()
fluxo = fluxo_original.copy()
#criar a serie de tempo mensal - para simulacao
end = max(df['dt_vencto'])
end = end + pd.DateOffset(months=2)
inicio = pd.to_datetime(start) + pd.DateOffset(months=1)
tempo = pd.DataFrame()
tempo['serie'] = pd.date_range(inicio, end, freq='M')
tempo['serie'] = tempo['serie'].dt.date
df = df.reset_index(level=None,
drop=False,
inplace=False,
col_level=0,
col_fill='')
df['dt_base'] = start
#primeira rodada
df['rtg'] = df['rating']
fim = pd.DataFrame()
#### simulacao
i_tempo = 0
while len(df) > 0:
np.random.seed(1234 + i_tempo + id_simulacao)
df['aleat_matriz'] = np.random.uniform(0, 1, len(df))
df['aleat_pd'] = np.random.uniform(0, 1, len(df))
df_matriz = pd.merge(df,
matriz_mes,
left_on=['rtg'],
right_on=['rtg_de'],
how='left')
df_rtg = df_matriz[
(df_matriz['prob_ini'] < df_matriz['aleat_matriz'])
& (df_matriz['aleat_matriz'] <= df_matriz['prob_fim'])]
df_rtg['rtg'] = df_rtg['rtg_para']
df_rtg['dt_ref'] = tempo['serie'][i_tempo]
# prazo=1 -> simulação mensal
df_rtg['prazo'] = 1
df_rtg1 = pd.merge(df_rtg,
pd_mes,
left_on=['tipo_pd', 'prazo', 'rtg'],
right_on=['produto', 'prazo', 'rtg'],
how='left')
df_rtg1['default'] = np.where(df_rtg1.pd_mensal > df_rtg1.aleat_pd,
1, 0)
df_rtg_mes = df_rtg1[[
'isin', 'cnpj', 'contraparte', 'dt_vencto', 'tipo_ativo',
'tipo_pd', 'rating', 'rtg', 'dt_ref', 'prazo', 'dt_base',
'pd_mensal', 'default'
]].copy()
df_rtg_mes['break'] = np.where(
(df_rtg_mes['default'] == 1) |
(pd.to_datetime(df_rtg_mes['dt_vencto']) <= pd.to_datetime(
df_rtg_mes['dt_ref'])), 1, 0)
default_break = df_rtg_mes[df_rtg_mes['break'] == 1].copy()
nao_default = df_rtg_mes[~(df_rtg_mes['break'] == 1)].copy()
fim = fim.append(default_break)
df = nao_default[[
'isin', 'cnpj', 'contraparte', 'dt_vencto', 'tipo_ativo',
'tipo_pd', 'rating', 'rtg', 'dt_base'
]].copy()
i_tempo = i_tempo + 1
fim = fim.rename(columns={'dt_ref': 'dt_default'})
fim['lgd'] = 0
base_default = fim[fim['default'] == 1].copy()
base_nao_default = fim[fim['default'] == 0].copy()
base_default = base_default.reset_index(level=None,
drop=False,
inplace=False,
col_level=0,
col_fill='')
del base_default['index']
for i_lgd in range(0, len(base_default)):
np.random.seed(123 + i_lgd + id_simulacao)
lgd_base_0 = lgd[lgd['produto'] == base_default['tipo_pd'][i_lgd]]
lgd_base = lgd_base_0.copy()
lgd_base['aleat_lgd'] = np.random.uniform(0, 1, len(lgd_base))
lgd_base = lgd_base.sort(['aleat_lgd'])
lgd_base = lgd_base.reset_index(level=None,
drop=False,
inplace=False,
col_level=0,
col_fill='')
lgd_perc = lgd_base.get_value(0, 'lgd')
base_default.loc[i_lgd, 'lgd'] = lgd_perc
##VALIDAR ESTA ITERAÇÃO:
#i_lgd=i_lgd+1
df_fim = base_nao_default.append(base_default)
df_fluxo = pd.merge(df_fim,
fluxo,
left_on=['isin'],
right_on=['isin'],
how='left')
df_fluxo = pd.merge(df_fluxo,
serie_dias,
left_on=['data_ref'],
right_on=['data_ref'],
how='left')
df_fluxo = df_fluxo.rename(columns={
'indice_du': 'du_ref',
'indice_dc': 'dc_ref'
})
df_fluxo = pd.merge(df_fluxo,
serie_dias,
left_on=['dt_default'],
right_on=['data_ref'],
how='left')
del df_fluxo['data_ref_y']
df_fluxo = df_fluxo.rename(
columns={
'indice_du': 'du_default',
'indice_dc': 'dc_default',
'data_ref_x': 'data_ref'
})
#___________________________CENARIO_______________________________________________
base_dt = pd.DataFrame(columns=['dt', 'aleat'])
base_dt['dt'] = cen2['dt_ref'].unique()
base_dt['aleat'] = np.random.uniform(0, 1, len(base_dt))
base_dt = base_dt.sort(['aleat'])
base_dt = base_dt.reset_index(level=None,
drop=False,
inplace=False,
col_level=0,
col_fill='')
base_dt = base_dt[['dt', 'aleat']]
dt_max = max(base_dt.dt)
base_ref_0 = cen2[cen2.dt_ref == dt_max]
base_ref = base_ref_0.copy()
del base_ref['dif']
dt = base_dt.get_value(0, 'dt')
#erro
erro_0 = cen2[cen2.dt_ref == dt]
erro = erro_0.copy()
erro = erro[['indexador_cod', 'prazo', 'dt_ref', 'dif']]
del erro['dt_ref']
base_ref = pd.merge(base_ref,
erro,
how='left',
left_on=['indexador_cod', 'prazo'],
right_on=['indexador_cod', 'prazo'])
base_ref['tx_spot_sim'] = base_ref['tx_spot'].astype(
float) + base_ref['dif'].astype(float)
del base_ref['indexador_shift']
del base_ref['prazo_shift']
del base_ref['tx_spot_shift']
del base_ref['dif']
#--fluxo e cenário
df_fluxo['indexador_cod'] = ""
df_fluxo['indexador_cod'] = np.where(df_fluxo.indexador == 'DI1',
'CDI', df_fluxo['indexador_cod'])
df_fluxo['indexador_cod'] = np.where(df_fluxo.indexador == 'CDI',
'CDI', df_fluxo['indexador_cod'])
df_fluxo['indexador_cod'] = np.where(df_fluxo.indexador == 'IAP',
'DIC', df_fluxo['indexador_cod'])
df_fluxo['indexador_cod'] = np.where(df_fluxo.indexador == 'IPC',
'DIC', df_fluxo['indexador_cod'])
df_fluxo['indexador_cod'] = np.where(df_fluxo.indexador == 'IGM',
'DIM', df_fluxo['indexador_cod'])
df_fluxo['indexador_cod'] = np.where(df_fluxo.indexador == 'PRE',
'PRE', df_fluxo['indexador_cod'])
df_fluxo['indexador_cod'] = np.where(df_fluxo.indexador == 'TR', 'TP',
df_fluxo['indexador_cod'])
df_fluxo['indexador_cod'] = np.where(df_fluxo.indexador == 'IGP',
'DIM', df_fluxo['indexador_cod'])
df_fluxo['indexador_cod'] = np.where(df_fluxo.indexador == 'IPCA',
'DIC', df_fluxo['indexador_cod'])
df_fluxo['indexador_cod'] = np.where(df_fluxo.indexador == 'IGPM',
'DIM', df_fluxo['indexador_cod'])
cenario = base_ref[['prazo', 'indexador_cod', 'tx_spot_sim']].copy()
df_fluxo_sim = pd.merge(df_fluxo,
cenario,
left_on=['du_ref', 'indexador_cod'],
right_on=['prazo', 'indexador_cod'],
how='left')
df_fluxo_sim['tx_spot_sim'] = df_fluxo_sim['tx_spot_sim'].fillna(0)
df_fluxo_sim['pv'] = df_fluxo_sim['fv'] / (1 +
df_fluxo_sim['tx_spot_sim'])
df_pv = df_fluxo_sim[['isin', 'pv']]
df_pv['pv'] = df_pv['pv'].fillna(0)
df_tot = df_pv.groupby(['isin'], as_index=False).sum()
df_fluxo_perda = df_fluxo_sim[
(pd.to_datetime(df_fluxo_sim['data_ref']) >= pd.to_datetime(
df_fluxo_sim['dt_default'])) & (df_fluxo_sim['default'] == 1)]
df_perda = df_fluxo_perda[['isin', 'tipo_ativo', 'lgd', 'pv']].copy()
df_perda['pv'] = df_perda['pv'].fillna(0)
df_perda_tot = df_perda.groupby(['isin', 'tipo_ativo', 'lgd'],
as_index=False).sum()
df_perda_tot['recuperacao'] = np.where(df_perda_tot.tipo_ativo == 'DP',
20000000, 0)
df_perda_tot['pv_perda'] = (df_perda_tot['pv'] * df_perda_tot['lgd'] -
df_perda_tot['recuperacao']).clip(0, None)
df_perda_tot1 = df_perda_tot[['isin', 'pv_perda']].copy()
df_resultado = pd.merge(df_tot,
df_perda_tot1,
left_on=['isin'],
right_on=['isin'],
how='left')
df_resultado['pv_perda'] = df_resultado['pv_perda'].fillna(0)
df_resultado[
'perda_perc'] = df_resultado['pv_perda'] / df_resultado['pv']
df_resultado['perda_perc'] = df_resultado['perda_perc'].fillna(0)
df_resultado['dt_base_sim'] = start
df_resultado['numero_simulacao'] = id_simulacao
df_resultado['data_bd'] = hoje
df_resultado['id_relatorio_qo'] = id_relatorio_qo
df_resultado['pv_perda'] = df_resultado['pv_perda'].fillna(0)
#Salvar no MySQL
logger.info("Conectando no Banco de dados")
connection = db.connect('localhost',
user='******',
passwd='root',
db='projeto_inv',
use_unicode=True,
charset="utf8")
logger.info("Conexão com DB executada com sucesso")
logger.info("Salvando base de dados")
pd.io.sql.to_sql(df_resultado,
name='simulacao_credito',
con=connection,
if_exists='append',
flavor='mysql',
index=0)
#Fecha conexão
connection.close()
hoje = pd.datetime.today()
for numero_sim in range(0, qtde_simulacao):
simulacao(numero_sim)
def get_bacen_indices():
import pandas as pd
import pymysql as db
import datetime
import logging
from pandas import DateOffset
from dependencias.Metodos.funcoes_auxiliares import full_path_from_database
from findt import FinDt
from pandas import ExcelWriter
logger = logging.getLogger(__name__)
#----Declaração de constantes
logger.info("Conectando no Banco de dados")
connection = db.connect('localhost',
user='******',
passwd='root',
db='projeto_inv')
logger.info("Conexão com DB executada com sucesso")
var_path = full_path_from_database(
"feriados_nacionais") + "feriados_nacionais.csv"
save_path = full_path_from_database("get_bacen_indices")
#----Input incremental baixado robos_diarios_bacen
# Fazer a query do que foi baixado pelo robo_diario_bacen
query = 'SELECT * FROM projeto_inv.bacen_series;'
bacen_series = pd.read_sql(query, con=connection)
logger.info("Leitura do banco de dados executada com sucesso")
logger.info("Tratando dados")
# Retira duplicatas
bacen_series = bacen_series.sort(['codigo', 'data_referencia', 'data_bd'],
ascending=[True, True, False])
bacen_series = bacen_series.drop_duplicates(
subset=['codigo', 'data_referencia'], take_last=False)
# Separa em dataframes de dias e meses
bacen_series_mensal = bacen_series[bacen_series.frequencia.isin(
['M'])].copy()
bacen_series_diario = bacen_series[bacen_series.frequencia.isin(
['D'])].copy()
# Retira duplicatas
bacen_series_mensal = bacen_series_mensal.drop_duplicates(
subset=['codigo'], take_last=True)
# Apenda com o dataframe diário
bacen_series = bacen_series_mensal.append(bacen_series_diario)
#Seleciona apenas IPCA, IGPM, CDI e TR
bacen_series = bacen_series[(bacen_series.codigo == 256) |
(bacen_series.codigo == 433) |
(bacen_series.codigo == 189) |
(bacen_series.codigo == 4389) |
(bacen_series.codigo == 7811)]
bacen_series['indice'] = None
#IPCA - Periodocidade Mensal; Composição Mensal
bacen_series['indice'][bacen_series.codigo == 433] = 'IPCA'
#IGPM - - Periodocidade Mensal; Composição Mensal
bacen_series['indice'][bacen_series.codigo == 189] = 'IGP'
#CDI - - Periodocidade Diária; Composição Anual
bacen_series['indice'][bacen_series.codigo == 4389] = 'DI1'
#TR - - Periodocidade Diária; Composição Mensal
bacen_series['indice'][bacen_series.codigo == 7811] = 'TR'
#TJLP - - Periodocidade Diária; Composição Mensal
bacen_series['indice'][bacen_series.codigo == 256] = 'TJLP'
bacen_series['data_referencia'] = bacen_series['data_referencia'].astype(
str)
bacen_series['ano'] = bacen_series['data_referencia'].str[0:4].astype(int)
bacen_series['mes'] = bacen_series['data_referencia'].str[5:7].astype(int)
bacen_series['dia'] = bacen_series['data_referencia'].str[8:10].astype(int)
bacen_series['dt_ref'] = pd.to_datetime(
bacen_series['data_referencia']).dt.date
del bacen_series['codigo']
del bacen_series['frequencia']
del bacen_series['nome']
del bacen_series['data_bd']
del bacen_series['id_bacen_series']
del bacen_series['data_referencia']
#----ATUALIZAÇÃO ÍNDICES - CARREGAMENTO HISTÓRICO
logger.info("Atualizando índices")
#Fazer a query do que foi baixado pelo robo_diario_anbima_projecoes
query = 'SELECT * FROM projeto_inv.bacen_series_hist;'
bacen_series_hist = pd.read_sql(query, con=connection)
logger.info("Leitura do banco de dados executada com sucesso")
bacen_series_hist = bacen_series_hist.sort(['indice', 'dt_ref', 'data_bd'],
ascending=[True, True, False])
bacen_series_hist = bacen_series_hist.drop_duplicates(
subset=['indice', 'dt_ref'], take_last=False)
del bacen_series_hist['id_bc_series_hist']
del bacen_series_hist['data_bd']
horario_bd = datetime.datetime.now()
#----ATUALIZAÇÃO ÍNDICES - APPEND DAS INFO NOVAS DAS SERIES BACEN
bacen_series_hist = bacen_series_hist.append(bacen_series)
bacen_series_hist = bacen_series_hist.sort(['indice', 'dt_ref'],
ascending=[True, True])
bacen_series_hist = bacen_series_hist.drop_duplicates(
subset=['indice', 'dt_ref'], take_last=False)
#----------CRIAÇÃO SÉRIE DIÁRIA
logger.info("Criando séries diária")
#Seleciona o última dia do mês vigente
mesfim = datetime.date.today().month + 1
fim = datetime.date(datetime.date.today().year, mesfim, 1) - DateOffset(
months=0, days=1)
dt_ref = pd.date_range(start='01/01/1996', end=fim, freq='D').date
ano = pd.date_range(start='01/01/1996', end=fim, freq='D').year
mes = pd.date_range(start='01/01/1996', end=fim, freq='D').month
dias = pd.date_range(start='01/01/1996', end=fim, freq='D').day
serie_dias = pd.DataFrame(columns=['dt_ref', 'ano', 'mes', 'dia'])
serie_dias['dt_ref'] = dt_ref
serie_dias['ano'] = ano
serie_dias['mes'] = mes
serie_dias['dia'] = dias
#identificar se é dia útil
dt_max = max(serie_dias['dt_ref'])
dt_min = min(serie_dias['dt_ref'])
per = FinDt.DatasFinanceiras(dt_min, dt_max, path_arquivo=var_path)
du = pd.DataFrame(columns=['dt_ref'])
du['dt_ref'] = per.dias(3)
du['du_1'] = 1
serie_dias = serie_dias.merge(du, on=['dt_ref'], how='left')
serie_dias['du_1'] = serie_dias['du_1'].fillna(0)
serie_dias['dc_1'] = 1
#calculo de dias corridos por mes
serie_dias_group_count = serie_dias[['dt_ref', 'ano',
'mes']].groupby(['ano', 'mes'
]).agg(['count'])
serie_dias_group_count = serie_dias_group_count.reset_index(level=None,
drop=False,
inplace=False,
col_level=0,
col_fill='')
serie_dias_group_count_filter = pd.DataFrame(columns=['ano', 'mes', 'dc'])
serie_dias_group_count_filter['ano'] = serie_dias_group_count['ano']
serie_dias_group_count_filter['mes'] = serie_dias_group_count['mes']
serie_dias_group_count_filter['dc'] = serie_dias_group_count['dt_ref']
serie_dias = serie_dias.merge(serie_dias_group_count_filter,
on=['ano', 'mes'],
how='left')
#calculo de dias uteis por mes
serie_dias_group_sum = serie_dias[['du_1', 'ano',
'mes']].groupby(['ano',
'mes']).agg(['sum'])
serie_dias_group_sum = serie_dias_group_sum.reset_index(level=None,
drop=False,
inplace=False,
col_level=0,
col_fill='')
serie_dias_group_sum_filter = pd.DataFrame(columns=['ano', 'mes', 'du'])
serie_dias_group_sum_filter['ano'] = serie_dias_group_sum['ano']
serie_dias_group_sum_filter['mes'] = serie_dias_group_sum['mes']
serie_dias_group_sum_filter['du'] = serie_dias_group_sum['du_1']
serie_dias = serie_dias.merge(serie_dias_group_sum_filter,
on=['ano', 'mes'],
how='left')
#----------CRIAÇÃO BASE DIÁRIA
logger.info("Criando bases diárias")
#----IPCA
ipca = bacen_series_hist[['mes', 'ano', 'valor', 'indice'
]][bacen_series_hist.indice == 'IPCA'].copy()
serie_dias_ipca = serie_dias.merge(ipca, on=['mes', 'ano'], how='left')
#Taxas acumuladas
serie_dias_ipca['fator_dia_du'] = (
1 + serie_dias_ipca['du_1'] * serie_dias_ipca['valor'] / 100)**(
1 / serie_dias_ipca['du'])
serie_dias_ipca['fator_dia_dc'] = (
1 + serie_dias_ipca['dc_1'] * serie_dias_ipca['valor'] / 100)**(
1 / serie_dias_ipca['dc'])
serie_dias_ipca['fator_acum_du'] = serie_dias_ipca[[
'indice', 'fator_dia_du'
]].groupby(['indice']).agg(['cumprod'])
serie_dias_ipca['fator_acum_dc'] = serie_dias_ipca[[
'indice', 'fator_dia_dc'
]].groupby(['indice']).agg(['cumprod'])
#----IGPM
igpm = bacen_series_hist[['mes', 'ano', 'valor', 'indice'
]][bacen_series_hist.indice == 'IGP'].copy()
serie_dias_igpm = serie_dias.merge(igpm, on=['mes', 'ano'], how='left')
#Taxas acumuladas
serie_dias_igpm['fator_dia_du'] = (
1 + serie_dias_igpm['du_1'] * serie_dias_igpm['valor'] / 100)**(
1 / serie_dias_igpm['du'])
serie_dias_igpm['fator_dia_dc'] = (
1 + serie_dias_igpm['dc_1'] * serie_dias_igpm['valor'] / 100)**(
1 / serie_dias_igpm['dc'])
serie_dias_igpm['fator_acum_du'] = serie_dias_igpm[[
'indice', 'fator_dia_du'
]].groupby(['indice']).agg(['cumprod'])
serie_dias_igpm['fator_acum_dc'] = serie_dias_igpm[[
'indice', 'fator_dia_dc'
]].groupby(['indice']).agg(['cumprod'])
#----CDI
cdi = bacen_series_hist[['dia', 'mes', 'ano', 'valor', 'indice'
]][bacen_series_hist.indice == 'DI1'].copy()
serie_dias_cdi = serie_dias.merge(cdi,
on=['dia', 'mes', 'ano'],
how='left')
serie_dias_cdi['indice'] = serie_dias_cdi['indice'].fillna('DI1')
serie_dias_cdi['valor'] = serie_dias_cdi['valor'].fillna(0)
#Taxas acumuladas
serie_dias_cdi['fator_dia_du'] = (
1 + serie_dias_cdi['du_1'] * serie_dias_cdi['valor'] / 100)**(1 / 252)
serie_dias_cdi['fator_dia_dc'] = None
serie_dias_cdi['fator_acum_du'] = serie_dias_cdi[[
'indice', 'fator_dia_du'
]].groupby(['indice']).agg(['cumprod'])
serie_dias_cdi['fator_acum_dc'] = None
#----TR
tr = bacen_series_hist[['mes', 'ano', 'valor', 'indice'
]][bacen_series_hist.indice == 'TR'].copy()
serie_dias_tr = serie_dias.merge(tr, on=['mes', 'ano'], how='left')
#----TJLP
tjlp = bacen_series_hist[['mes', 'ano', 'valor', 'indice'
]][bacen_series_hist.indice == 'TJLP'].copy()
serie_dias_tjlp = serie_dias.merge(tjlp, on=['mes', 'ano'], how='left')
#Taxas acumuladas
serie_dias_tr['fator_dia_du'] = (
1 + serie_dias_tr['du_1'] * serie_dias_tr['valor'] / 100)**(
1 / serie_dias_tr['du'])
serie_dias_tr['fator_dia_dc'] = (
1 + serie_dias_tr['dc_1'] * serie_dias_tr['valor'] / 100)**(
1 / serie_dias_tr['dc'])
serie_dias_tr['fator_acum_du'] = serie_dias_tr[['indice',
'fator_dia_du']].groupby([
'indice'
]).agg(['cumprod'])
serie_dias_tr['fator_acum_dc'] = serie_dias_tr[['indice',
'fator_dia_dc']].groupby([
'indice'
]).agg(['cumprod'])
serie_dias_indices = serie_dias_ipca.copy()
serie_dias_indices = serie_dias_indices.append(serie_dias_igpm)
serie_dias_indices = serie_dias_indices.append(serie_dias_cdi)
serie_dias_indices = serie_dias_indices.append(serie_dias_tr)
serie_dias_indices = serie_dias_indices.append(serie_dias_tjlp)
serie_dias_indices = serie_dias_indices[
serie_dias_indices.fator_dia_du.notnull()]
serie_dias_indices = serie_dias_indices.reset_index(level=None,
drop=True,
inplace=False,
col_level=0,
col_fill='')
writer = ExcelWriter(save_path + 'serie_dias_indices.xlsx')
serie_dias_indices.to_excel(writer, 'Todos')
serie_dias_ipca.to_excel(writer, 'IPCA')
serie_dias_igpm.to_excel(writer, 'IGPM')
serie_dias_cdi.to_excel(writer, 'DI')
serie_dias_tr.to_excel(writer, 'TR')
serie_dias_tjlp.to_excel(writer, 'TJLP')
writer.save()
serie_dias_indices['data_bd'] = horario_bd
#----------VERIFICAÇÃO PARA CRIAR A TABELA INCREMENTAL
query = 'SELECT * FROM projeto_inv.bacen_series_fatores;'
bc_series = pd.read_sql(query, con=connection)
logger.info("Leitura do banco de dados executada com sucesso")
bc_series = bc_series[['indice', 'dt_ref']].copy()
bc_series['marker'] = 1
serie_dias_indices = serie_dias_indices.merge(bc_series,
on=['indice', 'dt_ref'],
how='left')
serie_dias_indices = serie_dias_indices[
serie_dias_indices.marker.isnull()].copy()
del serie_dias_indices['marker']
logger.info("Salvando base de dados - Tabela bacen_series_fatores")
#Salvar no MySQL
pd.io.sql.to_sql(serie_dias_indices,
name='bacen_series_fatores',
con=connection,
if_exists='append',
flavor='mysql',
index=0)
#Fecha conexao
connection.close()
def titpublico_final_pv_ettj():
import pandas as pd
import pymysql as db
import numpy as np
import datetime
import logging
from findt import FinDt
from dependencias.Metodos.funcoes_auxiliares import get_data_ultimo_dia_util_mes_anterior
from dependencias.Metodos.funcoes_auxiliares import full_path_from_database
from dependencias.Metodos.funcoes_auxiliares import get_global_var
logger = logging.getLogger(__name__)
#----Declaração de constantes
# Pega a data do último dia útil do mês anterior e deixa no formato específico para utilização da função
dtbase = get_data_ultimo_dia_util_mes_anterior()
# Auxiliar para pegar vna existente na base - versão dummie
dt_vna = get_global_var(dt_vna)
dt_vna = datetime.date(int(dt_vna[0:4]), int(dt_vna[4:6]), int(dt_vna[6:8]))
# Quando tiver vna da data de posicao
# dt_vna = dt_base
dt_base = datetime.date(int(dtbase[0]), int(dtbase[1]), int(dtbase[2]))
# Diretório de save de planilhas
save_path_tpf_fluxo_final = full_path_from_database('get_output_quadro419') + 'tpf_fluxo_final.xlsx'
feriados_sheet = full_path_from_database('feriados_nacionais') + 'feriados_nacionais.csv'
#----Leitura do HEADER para pegar a data de referencia do relatório
#Informações XML
logger.info("Conectando no Banco de dados")
connection = db.connect('localhost', user='******', passwd='root', db='projeto_inv'
, use_unicode=True, charset="utf8")
logger.info("Conexão com DB executada com sucesso")
query = 'select * from projeto_inv.xml_header_org'
xml_header = pd.read_sql(query, con=connection)
logger.info("Leitura do banco de dados executada com sucesso")
xml_header = xml_header[xml_header.dtposicao == dt_base].copy()
xml_header = xml_header[xml_header.data_bd == max(xml_header.data_bd)].copy()
horario_bd = datetime.datetime.today()
#----Seleção da tabela xml_titpublico
# Seleção da tabela de TITPUBLICO
query = 'SELECT * FROM projeto_inv.xml_titpublico_org'
tpf_xml = pd.read_sql(query, con=connection)
logger.info("Leitura do banco de dados executada com sucesso")
aux = xml_header[['dtposicao','header_id']].copy()
aux['marcador'] = 1
#Seleção da carga mais recente referente à data base do relatório
tpf_xml = tpf_xml.merge(aux,on=['header_id'],how='left')
tpf_xml = tpf_xml[tpf_xml.marcador==1]
tpf_xml = tpf_xml[tpf_xml.data_bd==max(tpf_xml.data_bd)]
#Mudança de formato
tpf_xml['codativo'] = tpf_xml['codativo'].fillna(0)
tpf_xml['codativo'] = tpf_xml['codativo'].astype(int)
del tpf_xml['data_bd']
del tpf_xml['marcador']
del tpf_xml['pu_mercado']
del tpf_xml['mtm_mercado']
del tpf_xml['pu_curva']
del tpf_xml['mtm_curva']
del tpf_xml['pu_regra_xml']
del tpf_xml['mtm_regra_xml']
del tpf_xml['data_referencia']
#----Marcação na curva
#Seleção dos inputs e chaves
tpf_curva = tpf_xml[['codativo','dtvencimento','dtposicao','dtoperacao','coupom','id_papel']].copy()
#Mudanças necessárias de formato
tpf_curva['coupom'] = tpf_curva['coupom'].astype(float)
#Data de referência da posição
tpf_curva['data_posicao_curva'] = dt_base
fluxo = pd.read_sql('select * from projeto_inv.anbima_fluxo_tpf;', con=connection)
logger.info("Leitura do banco de dados executada com sucesso")
fluxo = fluxo.sort(['titulo','dt_vencto', 'dt_ref', 'data_bd'], ascending=[True, True, True, False])
fluxo = fluxo.drop_duplicates(subset=['titulo', 'dt_vencto', 'dt_ref'], take_last=False)
fluxo = fluxo.reset_index(level=None, drop=True, inplace=False, col_level=0, col_fill='')
fluxo = fluxo.rename(columns={'dt_vencto':'dtvencimento','cod_selic':'codativo'})
#Retirada de colunas não utilizadas
del fluxo['titulo']
del fluxo['dt_emissao']
del fluxo['cupom']
del fluxo['dt_vencto2']
del fluxo['data_bd']
#Seleção do fluxo futuro à data da posição
fluxo = fluxo[fluxo.dt_ref>=dt_base].copy()
#Chamada de valores de VNA
query = 'SELECT * FROM projeto_inv.anbima_vna'
vna_virgem = pd.read_sql(query, con=connection)
logger.info("Leitura do banco de dados executada com sucesso")
vna = vna_virgem.sort(['codigo_selic','data_referencia','data_bd'], ascending=[True, False, False])
vna = vna.drop_duplicates(subset=['codigo_selic','data_referencia'], take_last=False)
vna = vna.reset_index(level=None, drop=True, inplace=False, col_level=0, col_fill='')
vna = vna.rename(columns={'codigo_selic':'codativo'})
#Mudança de formato
#Seleção vna na data da posição
vna = vna[vna.data_referencia==dt_vna].copy()
#Retirada de colunas não utilizadas
del vna['id_anbima_vna']
del vna['titulo']
del vna['data_referencia']
del vna['data_bd']
#Agregação do vna à tabela fluxo
fluxo = fluxo.merge(vna,on=['codativo'],how='left')
fluxo['vna'] = fluxo['vna'].fillna(1000.0)
#Agregaçào do fluxo à tabela tpf_curva
tpf_curva = pd.merge(tpf_curva,fluxo,right_on=['codativo','dtvencimento'], left_on=['codativo','dtvencimento'], how='left')
#Criação da lista de datas para trazer o fv a vp
#Começa a contar a partir da data da posição
dt_min = dt_base
tpf_curva['dt_ref']=pd.to_datetime(tpf_curva['dt_ref'])
dt_max = max(tpf_curva['dt_ref'])
dt_max = dt_max.to_datetime()
dt_max=dt_max.date()
dt_ref = pd.date_range(start=dt_min, end=dt_max, freq='D').date
serie_dias = pd.DataFrame(columns=['dt_ref'])
serie_dias['dt_ref'] = dt_ref
per = FinDt.DatasFinanceiras(dt_min, dt_max, path_arquivo=feriados_sheet)
du = pd.DataFrame(columns=['dt_ref'])
du['dt_ref'] = per.dias(3)
du['du_flag'] = 1
serie_dias = serie_dias.merge(du,on=['dt_ref'],how='left')
serie_dias['du_flag'] = serie_dias['du_flag'].fillna(0)
serie_dias['prazo_du'] = np.cumsum(serie_dias['du_flag']) - 1
del serie_dias['du_flag']
#Agregação da tabela serie_dias à tpf_curva
tpf_curva['dt_ref'] = tpf_curva['dt_ref'].dt.date
tpf_curva = tpf_curva.merge(serie_dias,on=['dt_ref'],how='left')
#Cálculo do pv
tpf_curva['pv'] = tpf_curva['fv']*tpf_curva['vna']/(1+tpf_curva['coupom']/100)**(tpf_curva['prazo_du']/252)
tpf_curva['pv'] = np.where(tpf_curva['codativo']==210100,tpf_curva['fv']*tpf_curva['vna'],tpf_curva['pv'])
#Cálculo da marcação na curva
y = tpf_curva[['id_papel','pv']].groupby(['id_papel']).agg(['sum'])
y = y.reset_index(level=None, drop=False, inplace=False, col_level=0, col_fill='')
y1 = pd.DataFrame(columns=['id_papel','pu_curva'])
y1['id_papel'] = y['id_papel']
y1['pu_curva'] = y['pv']
tpf_curva = tpf_curva.merge(y1,on=['id_papel'],how='left')
#Seleção das colunas necessárias
tpf_curva = tpf_curva[['id_anbima_fluxo_tpf','id_papel','codativo','dtvencimento','dtoperacao','data_posicao_curva','pu_curva','fv','prazo_du']].copy()
#----Informações de mercado
#--Cria a base de valores marcados a mercado
query = 'SELECT * FROM projeto_inv.anbima_tpf'
base_anbima_virgem = pd.read_sql(query, con=connection)
logger.info("Leitura do banco de dados executada com sucesso")
base_anbima = base_anbima_virgem[base_anbima_virgem.dt_referencia<=dt_base]
base_anbima = base_anbima[['cod_selic','dt_vencto','pu','dt_referencia','dt_carga','tx_indicativa']].copy()
base_anbima = base_anbima.sort(['cod_selic','dt_vencto','dt_referencia','dt_carga'],ascending=[True,True,False,False])
base_anbima = base_anbima.drop_duplicates(subset=['cod_selic','dt_vencto'],take_last=False)
base_anbima = base_anbima[base_anbima.dt_referencia==dt_base].copy()
base_anbima = base_anbima.rename(columns = {'cod_selic':'codativo','dt_vencto':'dtvencimento','dt_referencia':'data_referencia','pu':'pu_mercado'})
del base_anbima['dt_carga']
#----União das colunas de marcação a mercado e marcação na curva
tpf = tpf_curva.merge(base_anbima,on=['codativo','dtvencimento'],how='left')
del tpf['codativo']
del tpf['dtvencimento']
del tpf['dtoperacao']
tpf_xml = tpf_xml.merge(tpf,on=['id_papel'],how='left')
tpf_full = tpf_xml.copy()
tpf_xml = tpf_xml.drop_duplicates(subset=['id_papel'])
#Seção Compromisso
tpf_xml['pu_mercado'] = np.where(tpf_xml['dtretorno'].notnull(),tpf_xml['puposicao'],tpf_xml['pu_mercado'])
tpf_xml['pu_curva'] = np.where(tpf_xml['dtretorno'].notnull(),tpf_xml['puposicao'],tpf_xml['pu_curva'])
tpf_xml['mtm_curva'] = tpf_xml['pu_curva']*(tpf_xml['qtdisponivel'] + tpf_xml['qtgarantia'])
tpf_xml['mtm_mercado'] = tpf_xml['pu_mercado']*(tpf_xml['qtdisponivel'] + tpf_xml['qtgarantia'])
tpf_xml['pu_regra_xml'] = np.where(tpf_xml['caracteristica']=='V',tpf_xml['pu_curva'],tpf_xml['pu_mercado'])
tpf_xml['mtm_regra_xml'] = np.where(tpf_xml['caracteristica']=='V',tpf_xml['mtm_curva'],tpf_xml['mtm_mercado'])
tpf_xml['data_bd'] = horario_bd
del tpf_xml['id_xml_titpublico']
del tpf_xml['dtposicao']
del tpf_xml['data_posicao_curva']
del tpf_xml['fv']
del tpf_xml['prazo_du']
del tpf_xml['id_anbima_fluxo_tpf']
del tpf_xml['tx_indicativa']
logger.info("Salvando base de dados - xml_titpublico")
pd.io.sql.to_sql(tpf_xml, name='xml_titpublico', con=connection, if_exists='append', flavor='mysql', index=0)
#----Trazer fv das LTN a vp, calcular o perc_mtm , DV100 e Duration
#Fator de desconto
dia = str(dt_base.day)
if len(dia) == 1:
dia = '0'+dia
mes = str(dt_base.month)
if len(mes) == 1:
mes = '0'+mes
ano = str(dt_base.year)
#dt_base_str = ano + '-' + mes + '-' + dia
tpf_full['indexador'] = np.where(tpf_full['indexador']=='IAP','IPCA',tpf_full['indexador'])
tpf_full['indexador'] = np.where(tpf_full['indexador']=='IGP','IGP',tpf_full['indexador'])
tpf_full['indexador'] = np.where(tpf_full['codativo'].isin([760100,760199]),'IPCA',tpf_full['indexador'])
tpf_full['indexador'] = np.where(tpf_full['codativo'].isin([770100]),'IGP',tpf_full['indexador'])
tpf_full['indexador'] = np.where(tpf_full['codativo'].isin([210100]),'PRE',tpf_full['indexador'])
tpf_pv = tpf_full.copy()
#Cálculo dos fatores de desconto, normal e estressado
dt_base = str(dt_base)
query = 'SELECT * FROM projeto_inv.curva_ettj_interpol_' + ano + '_' + mes + ' where day(dt_ref) = ' + dia + ' AND indexador_cod in("PRE","DIM","DIC");'
ettj = pd.read_sql(query, con=connection)
logger.info("Leitura do banco de dados executada com sucesso")
#Seleciona a última carga
ettj = ettj.sort(['indexador_cod','dt_ref', 'data_bd'], ascending = [True,False,False])
ettj = ettj.drop_duplicates(subset=['prazo','tx_spot', 'tx_spot_ano','tx_termo_dia','indexador_cod'], take_last=False)
ettj['indexador']=np.where(ettj['indexador_cod']=='DIC','IPCA',np.where(ettj['indexador_cod']=='DIM', 'IGP',np.where(ettj['indexador_cod']=='SLP','SEL','PRE')))
ettj=ettj.rename(columns={'prazo': 'prazo_du'})
ettj_filtro=ettj[['prazo_du', 'tx_spot', 'tx_spot_ano', 'indexador']]
tpf_pv = tpf_pv[tpf_pv.prazo_du>=0].copy()
tpf_pv = tpf_pv.merge(ettj_filtro,on=['indexador','prazo_du'],how='left')
tpf_pv['tx_spot'] = tpf_pv['tx_spot'].fillna(0)
tpf_pv['tx_spot_ano'] = tpf_pv['tx_spot_ano'].fillna(0)
tpf_pv['fator_desconto'] = 1/(1+tpf_pv['tx_spot'])
tpf_pv['fator_desconto_DV100'] = 1/(1+tpf_pv['tx_spot_ano']+0.01)**(tpf_pv['prazo_du']/252)
tpf_pv['pv'] = tpf_pv['fv']*tpf_pv['fator_desconto']
tpf_pv['pv_DV100'] = tpf_pv['fv']*tpf_pv['fator_desconto_DV100']
total_pv = tpf_pv[['id_papel', 'pv','fv']].copy()
total_pv = total_pv.groupby(['id_papel']).sum().reset_index()
total_pv = total_pv.rename(columns={'pv': 'pv_sum','fv':'fv_sum'})
tpf_pv = tpf_pv.merge(total_pv, on=['id_papel'], how='left')
tpf_pv['perc_mtm'] = tpf_pv['pv']/tpf_pv['pv_sum']
tpf_pv['perc_mtm_DV100'] = tpf_pv['pv_DV100']/tpf_pv['pv_sum']
#Cálculo do DV100
tpf_pv['DV100_fluxo'] = (tpf_pv['perc_mtm'] - tpf_pv['perc_mtm_DV100'])*tpf_pv['pu_mercado']
DV100 = tpf_pv[['id_papel', 'DV100_fluxo']].copy()
DV100 = DV100.groupby(['id_papel']).sum().reset_index()
DV100 = DV100.rename(columns={'DV100_fluxo':'DV100'})
tpf_pv = tpf_pv.merge(DV100, on=['id_papel'], how='left')
#Cálculo da Duration
tpf_pv['fluxo_ponderado'] = tpf_pv['perc_mtm']*tpf_pv['prazo_du']
duration = tpf_pv[['id_papel', 'fluxo_ponderado']].copy()
duration = duration.groupby(['id_papel']).sum().reset_index()
duration = duration.rename(columns={'fluxo_ponderado':'duration'})
tpf_pv = tpf_pv.merge(duration, on=['id_papel'], how='left')
#Normalizando para encaixar com as colunas de titprivado
tpf_pv['fluxo_ponderado'] = tpf_pv['fluxo_ponderado']*tpf_pv['pu_mercado']
tpf_pv['fv'] = tpf_pv['fv']*tpf_pv['pu_mercado']/tpf_pv['fv_sum']
del tpf_pv['pv_sum']
del tpf_pv['fv_sum']
del tpf_pv['DV100_fluxo']
del tpf_pv['perc_mtm_DV100']
del tpf_pv['tx_indicativa']
tpf_pv = tpf_pv.rename(columns={'isin':'codigo_isin','pu_mercado':'mtm','data_fim':'dt_ref'})
tpf_pv['data_mtm'] = dt_base
tpf_pv['data_negociacao'] = tpf_pv['data_referencia']
tpf_pv['ano_mtm'] = dt_base[0:4]
tpf_pv['mes_mtm'] = dt_base[5:7]
tpf_pv['dia_mtm'] = dt_base[8:10]
tpf_pv['indexador'] = np.where(tpf_pv['codativo'].isin([210100]),'SEL',tpf_pv['indexador'])
#Seleção das colunas finais
tpf_pv = tpf_pv[['id_anbima_fluxo_tpf',
'id_papel',
'codigo_isin',
'codativo',
'dtvencimento',
'prazo_du',
'fv',
'indexador',
'tx_spot',
'fator_desconto',
'fator_desconto_DV100',
'pv',
'pv_DV100',
'perc_mtm',
'DV100',
'fluxo_ponderado',
'duration',
'mtm',
'data_mtm',
'ano_mtm',
'mes_mtm',
'dia_mtm',
'data_negociacao']].copy()
#Cria o flag de tipo_ativo T(ítulo) P(úblico) F(eferal)
tpf_pv['tipo_ativo'] = 'TPF'
tpf_pv['data_bd'] = horario_bd
tpf_pv = tpf_pv.sort(['codigo_isin','codativo','prazo_du'],ascending=[True,True,True])
tpf_pv = tpf_pv.drop_duplicates(subset=['codigo_isin','codativo','dtvencimento','prazo_du'],take_last=True)
#Coloca na base mtmt_renda_fixa
logger.info("Salvando base de dados - mtm_renda_fixa")
pd.io.sql.to_sql(tpf_pv, name='mtm_renda_fixa', con=connection,if_exists="append", flavor='mysql', index=0)
#Fecha conexão
connection.close()
tpf_pv.to_excel(save_path_tpf_fluxo_final)
def mtm_curva_debenture():
import datetime, time
import pandas as pd
import pymysql as db
import numpy as np
import logging
from findt import FinDt
from pandas import ExcelWriter
from dependencias.Metodos.funcoes_auxiliares import get_data_ultimo_dia_util_mes_anterior
from dependencias.Metodos.funcoes_auxiliares import full_path_from_database
logger = logging.getLogger(__name__)
# Pega a data do último dia útil do mês anterior e deixa no formato específico para utilização da função
dtbase = get_data_ultimo_dia_util_mes_anterior()
dtbase_concat = dtbase[0] + dtbase[1] + dtbase[2]
# Diretório de save de planilhas
save_path_puposicao_final = full_path_from_database(
'get_output_quadro419') + 'puposicao_final_deb.xlsx'
save_path_teste_dif_deb = full_path_from_database(
'get_output_quadro419') + 'teste_dif_deb.xlsx'
feriados_sheet = full_path_from_database(
'feriados_nacionais') + 'feriados_nacionais.csv'
tol = 0.20
writer = ExcelWriter(save_path_puposicao_final)
dt_base_rel = datetime.date(int(dtbase[0]), int(dtbase[1]), int(dtbase[2]))
# 1 - Leitura e criação de tabelas
# Informações do cálculo de MTM
logger.info("Conectando no Banco de dados")
connection = db.connect('localhost',
user='******',
passwd='root',
db='projeto_inv',
use_unicode=True,
charset="utf8")
logger.info("Conexão com DB executada com sucesso")
query = "SELECT * FROM projeto_inv.mtm_titprivado WHERE tipo_ativo = 'DBS'"
#query = "SELECT * FROM projeto_inv.mtm_titprivado"
mtm_titprivado0 = pd.read_sql(query, con=connection)
logger.info("Leitura do banco de dados executada com sucesso")
mtm_titprivado = mtm_titprivado0.copy()
# Seleciona debentures
# Seleciona a última carga de debentures da data da posicao
mtm_titprivado['dtrel'] = mtm_titprivado['id_papel'].str.split('_')
mtm_titprivado['dtrel'] = mtm_titprivado['dtrel'].str[0]
mtm_titprivado = mtm_titprivado[mtm_titprivado.dtrel ==
dtbase_concat].copy()
mtm_titprivado = mtm_titprivado[mtm_titprivado.data_bd == max(
mtm_titprivado.data_bd)]
# Renomeia columnas
mtm_titprivado = mtm_titprivado.rename(columns={
'data_fim': 'dt_ref',
'dtoperacao': 'dtoperacao_mtm'
})
# Reajusta papéis indesaxos a DI
mtm_titprivado['dt_ref'] = pd.to_datetime(mtm_titprivado['dt_ref'])
mtm_titprivado['dt_ref'] = np.where(
mtm_titprivado['indexador'] == 'DI1',
mtm_titprivado['dt_ref'] + pd.DateOffset(months=0, days=1),
mtm_titprivado['dt_ref'])
mtm_titprivado['dt_ref'] = mtm_titprivado['dt_ref'].dt.date
# Altera o nome do id_papel para levar em consideração o flag
mtm_titprivado['id_papel_old'] = mtm_titprivado['id_papel']
mtm_titprivado['id_papel'] = mtm_titprivado['id_papel_old'].str.split('_')
mtm_titprivado['id_papel'] = mtm_titprivado['id_papel'].str[0] + '_' + mtm_titprivado['id_papel'].str[1] + '_' + \
mtm_titprivado['id_papel'].str[2]
del mtm_titprivado['data_bd']
del mtm_titprivado['dtrel']
query = 'SELECT * FROM projeto_inv.xml_debenture_org'
xml_titprivado = pd.read_sql(query, con=connection)
logger.info("Leitura do banco de dados executada com sucesso")
# Seleciona a última carga de debentures da data da posicao
xml_titprivado['dtrel'] = xml_titprivado['id_papel'].str.split('_')
xml_titprivado['dtrel'] = xml_titprivado['dtrel'].str[0]
xml_titprivado = xml_titprivado[xml_titprivado.dtrel ==
dtbase_concat].copy()
xml_titprivado = xml_titprivado[xml_titprivado.data_bd == max(
xml_titprivado.data_bd)]
original = xml_titprivado.copy()
del xml_titprivado['data_bd']
del xml_titprivado['indexador']
del xml_titprivado['dtrel']
# Puxa as informações de negociação em mercado secuindário da Anbima para debentures -> linha dtspread
query = 'SELECT * FROM projeto_inv.anbima_debentures'
anbima_deb = pd.read_sql(query, con=connection)
logger.info("Leitura do banco de dados executada com sucesso")
#Fecha conexão
connection.close()
anbima_deb = anbima_deb[anbima_deb.data_referencia <= dt_base_rel]
anbima_deb = anbima_deb.sort(['codigo', 'data_referencia', 'data_bd'],
ascending=[True, True, True])
anbima_deb = anbima_deb.drop_duplicates(subset=['codigo'], take_last=True)
anbima_deb = anbima_deb[['codigo', 'data_referencia', 'pu']].copy()
anbima_deb['codigo'] = anbima_deb['codigo'].astype(str)
anbima_deb = anbima_deb.rename(columns={
'codigo': 'coddeb',
'data_referencia': 'data_spread'
})
anbima_deb.coddeb.unique().tolist()
xml_titprivado.coddeb.unique().tolist()
# Criação da tabela xml + anbima
xml_titprivado = xml_titprivado.merge(anbima_deb,
on=['coddeb'],
how='left')
# Para os papéis que não tiveram negociação, assume data_spread = data_relatorio
xml_titprivado['data_spread'] = np.where(
xml_titprivado['data_spread'].isnull(), dt_base_rel,
xml_titprivado['data_spread'])
# Preenchimento com puposicao do xml no pu vindo da anbima quando não tem pu
# Tira o valor médio de todos os pu's posicao
x = xml_titprivado[['isin', 'puposicao']].groupby(['isin']).agg(['mean'])
x = x.reset_index(level=None,
drop=False,
inplace=False,
col_level=0,
col_fill='')
x1 = pd.DataFrame(columns=['isin', 'pumedio'])
x1['isin'] = x['isin']
x1['pumedio'] = x['puposicao']
xml_titprivado = xml_titprivado.merge(x1, on=['isin'], how='left')
xml_titprivado['pu'] = np.where(xml_titprivado['pu'].isnull(),
xml_titprivado['pumedio'],
xml_titprivado['pu'])
del xml_titprivado['pumedio']
# Criação da tabela mtm + xml
titprivado = xml_titprivado.merge(mtm_titprivado,
on=['id_papel'],
how='left')
# Criação da coluna de data de referencia da posição
titprivado['data_referencia'] = titprivado['id_papel'].str[0:8]
titprivado['data_referencia'] = pd.to_datetime(
titprivado['data_referencia']).dt.date
titprivado.caracteristica.unique()
logger.info("Cálculo marcação na curva")
# 2 - Cálculo marcação na curva
###### AQUI ZERA!!################# Verificar
titprivado_curva = titprivado[titprivado.caracteristica == 'V'].copy()
del titprivado_curva['vne']
# Seleciona a parte do fluxo entre a data da compra e a data da posição
titprivado_curva = titprivado_curva[
titprivado_curva.dt_ref >= titprivado_curva.dtoperacao_mtm].copy()
titprivado_curva = titprivado_curva[
titprivado_curva.dt_ref <= titprivado_curva.data_referencia].copy()
# Preenchimento do VNE na data da compra
tp_curva_dtop = titprivado_curva[[
'id_papel_old', 'saldo_dev_juros_perc', 'pucompra'
]][titprivado_curva.dt_ref == titprivado_curva.dtoperacao_mtm].copy()
tp_curva_dtop['vne'] = tp_curva_dtop['pucompra'] * (
1 - tp_curva_dtop['saldo_dev_juros_perc'])
del tp_curva_dtop['saldo_dev_juros_perc']
del tp_curva_dtop['pucompra']
titprivado_curva = titprivado_curva.merge(tp_curva_dtop,
on=['id_papel_old'],
how='left')
titprivado_curva[
'principal_perc_acum'] = 1 - titprivado_curva['principal_perc']
titprivado_curva['principal_perc_acum'] = titprivado_curva[[
'id_papel_old', 'principal_perc_acum'
]].groupby(['id_papel_old']).agg(['cumprod'])
titprivado_curva['vne'] = titprivado_curva['vne'] * titprivado_curva[
'principal_perc_acum']
titprivado_curva['pagto_juros'] = titprivado_curva[
'vne'] * titprivado_curva['pagto_juros_perc']
titprivado_curva[
'vna'] = titprivado_curva['vne'] * titprivado_curva['fator_index_per']
titprivado_curva['vna'][titprivado_curva.indexador ==
'DI1'] = titprivado_curva['vne'][
titprivado_curva.indexador == 'DI1']
titprivado_curva['saldo_dev_juros'] = titprivado_curva[
'vna'] * titprivado_curva['saldo_dev_juros_perc']
titprivado_curva['pupar'] = titprivado_curva['vna'] + titprivado_curva[
'saldo_dev_juros'] + titprivado_curva['pagto_juros']
titprivado_curva['dif_curva'] = titprivado_curva[
'pupar'] / titprivado_curva['puposicao'] - 1
titprivado_curva['dif_curva'] = titprivado_curva['dif_curva'].abs()
titprivado_curva = titprivado_curva[
titprivado_curva.dt_ref == titprivado_curva.data_referencia].copy()
titprivado_curva = titprivado_curva[[
'id_papel_old', 'id_papel', 'codigo_isin', 'dif_curva', 'pupar'
]].copy()
titprivado_curva = titprivado_curva.sort(['dif_curva'], ascending=[True])
titprivado_curva = titprivado_curva.drop_duplicates(subset=['id_papel'],
take_last=False)
titprivado = titprivado.merge(
titprivado_curva,
on=['id_papel_old', 'id_papel', 'codigo_isin'],
how='left')
titprivado = titprivado[((titprivado.caracteristica == 'V') &
(titprivado.dif_curva.notnull())) |
(titprivado.caracteristica == 'N')].copy()
titprivado = titprivado.reset_index(level=None,
drop=True,
inplace=False,
col_level=0,
col_fill='')
logger.info("Cálculo do mtm na data_spread; a)prazo_du_spread")
# 3 - Cálculo do mtm na data_spread; a) prazo_du_spread
# Verificação de papéis sem a data de referência
titprivado[titprivado.dt_ref.isnull()].to_excel(writer, 'dt_ref_NaN')
# Retira papéis sem data de referência
titprivado = titprivado[titprivado.dt_ref.notnull()].copy()
# Cria vetor das datas
dt_min = min(titprivado['dt_ref'])
dt_min = dt_min.replace(day=1)
dt_min = datetime.date(dt_min.year, dt_min.month, dt_min.day)
dt_max = max(titprivado['dt_ref'])
dt_max = dt_max.replace(day=1, month=dt_max.month)
dt_max = dt_max + pd.DateOffset(months=1)
dt_max = dt_max - pd.DateOffset(days=1)
dt_max = datetime.date(dt_max.year, dt_max.month, dt_max.day)
dt_ref = pd.date_range(start=dt_min, end=dt_max, freq='D').date
serie_dias = pd.DataFrame(columns=['dt_ref', 'aux'])
serie_dias['dt_ref'] = dt_ref
# Cria vetor das datas úteis
per = FinDt.DatasFinanceiras(dt_min, dt_max, path_arquivo=feriados_sheet)
du = pd.DataFrame(columns=['dt_ref'])
du['dt_ref'] = per.dias(3)
du['du_1'] = 1
serie_dias = serie_dias.merge(du, on=['dt_ref'], how='left')
serie_dias['du_1'] = serie_dias['du_1'].fillna(0)
serie_dias['indice_du'] = np.cumsum(serie_dias['du_1'])
del serie_dias['aux']
del serie_dias['du_1']
fim = serie_dias.copy()
fim = fim.rename(columns={'indice_du': 'indice_du_fim_spread'})
inicio = serie_dias.copy()
inicio = inicio.rename(columns={
'dt_ref': 'data_spread',
'indice_du': 'indice_du_inicio_spread'
})
# Une as séries dias à tabela titprivado
titprivado = titprivado.merge(fim, on=['dt_ref'], how='left')
titprivado = titprivado.merge(inicio, on=['data_spread'], how='left')
# Calcula o prazo_du_spread
titprivado['prazo_du_spread'] = titprivado[
'indice_du_fim_spread'] - titprivado['indice_du_inicio_spread']
logger.info("Cálculo do mtm na data_spread; b) taxa_spot")
# 4 - Cálculo do mtm na data_spread; b) taxa_spot
if len(titprivado[titprivado.indexador == 'PRE']) != 0:
maximo_tp_PRE = max(
titprivado['prazo_du_spread'][titprivado.indexador == 'PRE'])
if len(titprivado[titprivado.indexador == 'IGP']) != 0:
maximo_tp_IGPM = max(
titprivado['prazo_du_spread'][titprivado.indexador == 'IGP'])
if len(titprivado[titprivado.indexador == 'IPCA']) != 0:
maximo_tp_IPCA = max(
titprivado['prazo_du_spread'][titprivado.indexador == 'IPCA'])
# ----Base de interpolações para cálculo do spread
dt_min_interpol = str(min(titprivado['data_spread']))
logger.info("Conectando no Banco de dados")
connection = db.connect('localhost',
user='******',
passwd='root',
db='projeto_inv',
use_unicode=True,
charset="utf8")
logger.info("Conexão com DB executada com sucesso")
# Data de 2020 limite para a criacao das tabelas
dt_ref = pd.date_range(start=datetime.date(int(dt_min_interpol[0:4]),
int(dt_min_interpol[5:7]), 1),
end=datetime.date(int(2020), int(10), 31),
freq='M').date
# Uniao das tabelas criadas com union all
query = ''
for dt in dt_ref:
month = '0' + str(dt.month) if len(str(dt.month)) == 1 else str(
dt.month)
year = '0' + str(dt.year) if len(str(dt.year)) == 1 else str(dt.year)
query = query + 'SELECT * FROM projeto_inv.curva_ettj_interpol_' + year + "_" + month + " UNION ALL "
query = query[:-11]
query = 'select * from (' + query + ') AS a where dt_ref<=' + '"' + dtbase_concat + '" and dt_ref>=' + '"' + dt_min_interpol + '" and indexador_cod in("PRE","DIM","DIC");'
ettj = pd.read_sql(query, con=connection)
logger.info("Leitura do banco de dados executada com sucesso")
#Fecha conexão
connection.close()
# Seleciona a última carga
ettj = ettj.sort(['indexador_cod', 'dt_ref', 'data_bd'],
ascending=[True, False, False])
ettj = ettj.drop_duplicates(subset=[
'prazo', 'tx_spot', 'tx_spot_ano', 'tx_termo_dia', 'indexador_cod'
],
take_last=False)
ettj['indexador'] = np.where(
ettj['indexador_cod'] == 'DIC', 'IPCA',
np.where(ettj['indexador_cod'] == 'DIM', 'IGP', 'PRE'))
ettj = ettj.rename(columns={'prazo': 'prazo_du'})
ettj_filtro = ettj[['prazo_du', 'tx_spot', 'tx_spot_ano', 'indexador']]
ettj_filtro = ettj_filtro.rename(columns={'prazo_du': 'prazo_du_spread'})
# Extrapolação PRE, se necessário
if len(titprivado[titprivado.indexador == 'PRE']) != 0:
maximo_ettj = max(
ettj_filtro['prazo_du_spread'][ettj_filtro.indexador == 'PRE'])
# del ettj_fluxo
if maximo_ettj < max(
titprivado['prazo_du_spread'][titprivado.indexador == 'PRE']):
ettj_filtro_PRE = ettj_filtro[[
'prazo_du_spread', 'tx_spot_ano', 'indexador'
]][ettj_filtro.indexador == 'PRE'].copy()
ettj_filtro_PRE = ettj_filtro_PRE.reset_index(level=None,
drop=True,
inplace=False,
col_level=0,
col_fill='')
ettj_filtro_PRE = ettj_filtro_PRE[0:maximo_ettj - 1].copy()
tx_max = ettj_filtro_PRE['tx_spot_ano'].loc[len(ettj_filtro_PRE) -
1]
ettj_aux = pd.DataFrame(columns=['prazo_du_spread', 'indexador'])
ettj_aux['prazo_du_spread'] = np.linspace(1, maximo_tp_PRE,
maximo_tp_PRE)
ettj_aux['indexador'] = 'PRE'
ettj_aux = ettj_aux.merge(ettj_filtro_PRE,
on=['prazo_du_spread', 'indexador'],
how='left')
ettj_aux['tx_spot_ano'] = ettj_aux['tx_spot_ano'].fillna(tx_max)
ettj_aux['tx_spot'] = (1 + ettj_aux['tx_spot_ano'])**(
ettj_aux['prazo_du_spread'] / 252) - 1
ettj_fluxo = ettj_fluxo.append(ettj_aux)
else:
ettj_aux = ettj_filtro.copy()
ettj_fluxo = ettj_aux.copy()
else:
ettj_fluxo = ettj_filtro.copy()
# Extrapolação IGPM, se necessário
if len(titprivado[titprivado.indexador == 'IGP']) != 0:
maximo_ettj = max(
ettj_filtro['prazo_du_spread'][ettj_filtro.indexador == 'IGP'])
# del ettj_fluxo
if maximo_ettj < max(
titprivado['prazo_du_spread'][titprivado.indexador == 'IGP']):
ettj_filtro_IGPM = ettj_filtro[[
'prazo_du_spread', 'tx_spot_ano', 'indexador'
]][ettj_filtro.indexador == 'IGP'].copy()
ettj_filtro_IGPM = ettj_filtro_IGPM.reset_index(level=None,
drop=True,
inplace=False,
col_level=0,
col_fill='')
ettj_filtro_IGPM = ettj_filtro_IGPM[0:maximo_ettj - 1].copy()
tx_max = ettj_filtro_IGPM['tx_spot_ano'].loc[len(ettj_filtro_IGPM)
- 1]
ettj_aux = pd.DataFrame(columns=['prazo_du_spread', 'indexador'])
ettj_aux['prazo_du_spread'] = np.linspace(1, maximo_tp_IGPM,
maximo_tp_IGPM)
ettj_aux['indexador'] = 'IGP'
ettj_aux = ettj_aux.merge(ettj_filtro_IGPM,
on=['prazo_du_spread', 'indexador'],
how='left')
ettj_aux['tx_spot_ano'] = ettj_aux['tx_spot_ano'].fillna(tx_max)
ettj_aux['tx_spot'] = (1 + ettj_aux['tx_spot_ano'])**(
ettj_aux['prazo_du_spread'] / 252) - 1
ettj_fluxo = ettj_fluxo.append(ettj_aux)
else:
ettj_aux = ettj_filtro.copy()
ettj_fluxo = ettj_aux.copy()
else:
ettj_fluxo = ettj_filtro.copy()
# Extrapolação IPCA, se necessário
if len(titprivado[titprivado.indexador == 'IPCA']) != 0:
maximo_ettj = max(
ettj_filtro['prazo_du_spread'][ettj_filtro.indexador == 'IPCA'])
# del ettj_fluxo
if maximo_ettj < max(
titprivado['prazo_du_spread'][titprivado.indexador == 'IPCA']):
ettj_filtro_IPCA = ettj_filtro[[
'prazo_du_spread', 'tx_spot_ano', 'indexador'
]][ettj_filtro.indexador == 'IPCA'].copy()
ettj_filtro_IPCA = ettj_filtro_IPCA.reset_index(level=None,
drop=True,
inplace=False,
col_level=0,
col_fill='')
ettj_filtro_IPCA = ettj_filtro_IPCA[0:maximo_ettj - 1].copy()
tx_max = ettj_filtro_IPCA['tx_spot_ano'].loc[len(ettj_filtro_IPCA)
- 1]
ettj_aux = pd.DataFrame(columns=['prazo_du_spread', 'indexador'])
ettj_aux['prazo_du_spread'] = np.linspace(1, maximo_tp_IPCA,
maximo_tp_IPCA)
ettj_aux['indexador'] = 'IPCA'
ettj_aux = ettj_aux.merge(ettj_filtro_IPCA,
on=['prazo_du_spread', 'indexador'],
how='left')
ettj_aux['tx_spot_ano'] = ettj_aux['tx_spot_ano'].fillna(tx_max)
ettj_aux['tx_spot'] = (1 + ettj_aux['tx_spot_ano'])**(
ettj_aux['prazo_du_spread'] / 252) - 1
ettj_fluxo = ettj_fluxo.append(ettj_aux)
else:
ettj_aux = ettj_filtro.copy()
ettj_fluxo = ettj_aux.copy()
else:
ettj_fluxo = ettj_filtro.copy()
# Une a ETTJ à tabela titprivado
ettj_fluxo = ettj_fluxo.rename(columns={
'tx_spot': 'tx_spot_spread',
'tx_spot_ano': 'tx_spot_ano_spread'
})
titprivado = titprivado.merge(ettj_fluxo,
on=['prazo_du_spread', 'indexador'],
how='left')
# Preenche com 0 onde não tem taxa spot (prazo_su_spread<0, indexador=DI1)
titprivado['tx_spot_spread'] = titprivado['tx_spot_spread'].fillna(0)
titprivado['tx_spot_ano_spread'] = titprivado['tx_spot_ano_spread'].fillna(
0)
logger.info("Cálculo do mtm na data_spread; b) valor presente e mtm")
# 5 - Cálculo do mtm na data_spread; c) valor presente e mtm
titprivado['fator_desconto_spread'] = 1 / (1 +
titprivado['tx_spot_spread'])
titprivado[
'pv_spread'] = titprivado['fv'] * titprivado['fator_desconto_spread']
titprivado['pv_spread'] = np.where(titprivado['prazo_du_spread'] < 0, 0,
titprivado['pv_spread'])
x = titprivado[['id_papel',
'pv_spread']].groupby(['id_papel']).agg(['sum'])
x = x.reset_index(level=None,
drop=False,
inplace=False,
col_level=0,
col_fill='')
x1 = pd.DataFrame(columns=['id_papel', 'mtm_spread'])
x1['id_papel'] = x['id_papel']
x1['mtm_spread'] = x['pv_spread']
titprivado = titprivado.merge(x1, on=['id_papel'], how='left')
titprivado['dif'] = titprivado['mtm_spread'] / titprivado['pu'] - 1
writer = ExcelWriter(save_path_puposicao_final)
aux = titprivado.drop_duplicates(subset=['codigo_isin'])
aux[[
'id_papel_old', 'codigo_isin', 'flag', 'indexador', 'puemissao',
'data_emissao', 'data_expiracao', 'puposicao', 'percentual_indexador',
'taxa_juros', 'pu', 'mtm_spread', 'dif'
]].to_excel(writer, 'dif')
logger.info("Cálculo spread de crédito")
# 6 - Cálculo spread de crédito
titprivado_spread = \
titprivado[['id_papel', 'codigo_isin', 'data_spread', 'pu', 'dt_ref', 'prazo_du_spread', 'pv_spread']][
(titprivado.caracteristica == 'N') & (titprivado.dif != 1)]
# Seleciona apenas o fluxo com prazo_du positivo
titprivado_spread = titprivado_spread[
titprivado_spread.dt_ref >= titprivado_spread.data_spread]
titprivado_spread = titprivado_spread.drop_duplicates(
subset=['id_papel', 'prazo_du_spread'])
titprivado_spread['pv_pv_fluxo'] = np.where(
titprivado_spread['dt_ref'] == titprivado_spread['data_spread'],
-titprivado_spread['pu'], titprivado_spread['pv_spread'])
tp_spread = titprivado_spread[[
'id_papel', 'dt_ref', 'prazo_du_spread', 'pv_pv_fluxo'
]].copy()
tp_spread['prazo_du'] = tp_spread['prazo_du_spread'].astype(float)
tp_spread = tp_spread.drop_duplicates(
subset=['id_papel', 'prazo_du_spread'], take_last=True)
id_papel = titprivado_spread['id_papel'].unique()
spread = np.zeros((len(id_papel)))
spread_aux = pd.DataFrame(columns=['id_papel', 'spread'])
spread_aux['id_papel'] = id_papel
start_time = time.time()
for i in range(0, len(id_papel)):
v = tp_spread['pv_pv_fluxo'][tp_spread.id_papel == id_papel[i]].values
v = np.meshgrid(v, sparse=True)
s = np.linspace(-0.9999, 0.9999, 10000)
t = tp_spread['prazo_du_spread'][tp_spread.id_papel ==
id_papel[i]].values
t, s = np.meshgrid(t, s, sparse=True)
f_ts = 1. / (1 + s)**(t / 252)
f_spread = v * f_ts
f_sum = f_spread.sum(axis=1, dtype='float')
min_index = abs(f_sum).argmin()
spread[i] = s[min_index]
print(time.time() - start_time, i, id_papel[i], spread[i])
spread_aux['spread'].iloc[i] = spread[i]
titprivado = titprivado.merge(spread_aux, on=['id_papel'], how='left')
aux = titprivado.drop_duplicates(subset=['id_papel'])
aux[[
'id_papel_old', 'codigo_isin', 'valor_nominal', 'puposicao',
'mtm_spread', 'pu', 'spread'
]].to_excel(save_path_teste_dif_deb)
logger.info("Seleção dos papéis cuja marcação não ficou boa")
# 7 - Seleção dos papéis cuja marcação não ficou boa
tp_bigdif = titprivado[[
'data_spread', 'codigo_isin', 'id_papel', 'flag', 'indexador',
'dtemissao', 'data_emissao', 'dtvencimento', 'data_expiracao',
'valor_nominal', 'puemissao', 'juros_cada', 'coupom', 'taxa_juros',
'percentual_indexador', 'percindex', 'perc_amortizacao', 'dt_ref',
'vne', 'du_per', 'prazo_du', 'fator_index_per', 'fator_juros_per',
'pv', 'fv', 'mtm', 'puposicao', 'pu', 'dif', 'spread'
]].copy()
tp_bigdif['dif'] = tp_bigdif['mtm'] / tp_bigdif['pu'] - 1
tp_bigdif[(tp_bigdif.dif > tol) | (tp_bigdif.dif < -tol) |
(tp_bigdif.spread > tol) | (tp_bigdif.spread < -tol)].to_excel(
writer, 'bigdif')
logger.info(
"Atualização do fluxo de percentual de mtm com o spread e carregamento da tabela"
)
# 8 - Atualização do fluxo de percentual de mtm com o spread e carregamento da tabela para preenchimento do quadro 419
titprivado_perc = titprivado.copy()
titprivado_perc = titprivado_perc.rename(
columns={
'mtm': 'mtm_old',
'pv': 'pv_old',
'pv_DV100': 'pv_DV100_old',
'fator_desconto': 'fator_desconto_old',
'fator_desconto_DV100': 'fator_desconto_DV100_old',
'DV100': 'DV100_old'
})
# Escolhe o melhor spread - SIGNIFICA O MELHOR FLUXO
titprivado_perc['spread'] = titprivado_perc['spread'].fillna(0)
# Pega penas uma linha para não ter problemas
x = titprivado_perc[[
'id_papel', 'codigo_isin', 'spread'
]][titprivado_perc.dt_ref == titprivado_perc.data_referencia].copy()
x = x.sort(['codigo_isin', 'spread'], ascending=[True, True])
x = x.drop_duplicates(subset=['codigo_isin'], take_last=False)
x['marker'] = 1
titprivado_perc = titprivado_perc.merge(
x, on=['codigo_isin', 'id_papel', 'spread'], how='left')
titprivado_perc = titprivado_perc[titprivado_perc.marker == 1].copy()
del titprivado_perc['marker']
titprivado_perc = titprivado_perc.drop_duplicates(
subset=['codigo_isin', 'dt_ref'], take_last=True)
# titprivado_perc['puposicao_final'] = np.where(titprivado_perc['caracteristica']=='N',titprivado_perc['pu'],titprivado_perc['mtm_old'])
titprivado_perc = titprivado_perc[titprivado_perc.prazo_du >= 0]
aux = titprivado_perc[[
'id_papel', 'codigo_isin'
]][titprivado_perc.dt_ref == titprivado_perc.data_referencia].copy()
aux = aux.drop_duplicates(subset=['codigo_isin'], take_last=True)
aux['marker'] = 1
titprivado_perc = titprivado_perc.merge(aux,
on=['id_papel', 'codigo_isin'],
how='left')
titprivado_perc = titprivado_perc[titprivado_perc.marker == 1].copy()
del titprivado_perc['marker']
# Recalcula apenas para que está marcado a mercado
aux = titprivado_perc[titprivado_perc.caracteristica == 'V'].copy()
aux['mtm_DV100_N'] = 0.0
aux = aux.rename(columns={'mtm_old': 'mtm'})
titprivado_perc = titprivado_perc[titprivado_perc.caracteristica ==
'N'].copy()
# Cálculo do fator de desconto atualizado pelo spread
titprivado_perc[
'fator_desconto'] = titprivado_perc['fator_desconto_old'] / (
1 + titprivado_perc['spread'])**(titprivado_perc['prazo_du'] / 252)
titprivado_perc['fator_desconto_DV100'] = titprivado_perc[
'fator_desconto_DV100_old'] / (1 + titprivado_perc['spread'])**(
titprivado_perc['prazo_du'] / 252)
# Calculo do pv
titprivado_perc[
'pv'] = titprivado_perc['fv'] * titprivado_perc['fator_desconto']
titprivado_perc['pv_DV100'] = titprivado_perc['fv'] * titprivado_perc[
'fator_desconto_DV100']
# Calculo do MTM
x = titprivado_perc[['codigo_isin', 'pv',
'pv_DV100']].groupby(['codigo_isin']).agg(['sum'])
x = x.reset_index(level=None,
drop=False,
inplace=False,
col_level=0,
col_fill='')
x1 = pd.DataFrame(columns=['codigo_isin', 'mtm', 'mtm_DV100_N'])
x1['codigo_isin'] = x['codigo_isin']
x1['mtm'] = x['pv']
x1['mtm_DV100_N'] = x['pv_DV100']
titprivado_perc = titprivado_perc.merge(x1, on=['codigo_isin'], how='left')
titprivado_perc['mtm_DV100'] = 0.0
# Escolhe o melhor fluxo
titprivado_perc['dif_new'] = titprivado_perc['mtm'] - titprivado_perc['pu']
titprivado_perc['dif_new'] = titprivado_perc['dif_new'].abs()
titprivado_perc[
'dif_old'] = titprivado_perc['mtm_old'] - titprivado_perc['pu']
titprivado_perc['dif_old'] = titprivado_perc['dif_old'].abs()
titprivado_perc['mtm'] = np.where(
titprivado_perc['dif_old'] < titprivado_perc['dif_new'],
titprivado_perc['mtm_old'], titprivado_perc['mtm'])
titprivado_perc['mtm_DV100'] = np.where(
titprivado_perc['dif_old'] < titprivado_perc['dif_new'],
titprivado_perc['mtm_DV100'], titprivado_perc['mtm_DV100_N'])
titprivado_perc['pv'] = np.where(
titprivado_perc['dif_old'] < titprivado_perc['dif_new'],
titprivado_perc['pv_old'], titprivado_perc['pv'])
titprivado_perc['pv_DV100'] = np.where(
titprivado_perc['dif_old'] < titprivado_perc['dif_new'],
titprivado_perc['pv_DV100_old'], titprivado_perc['pv_DV100'])
titprivado_perc['fator_desconto'] = np.where(
titprivado_perc['dif_old'] < titprivado_perc['dif_new'],
titprivado_perc['fator_desconto_old'],
titprivado_perc['fator_desconto'])
titprivado_perc['fator_desconto_DV100'] = np.where(
titprivado_perc['dif_old'] < titprivado_perc['dif_new'],
titprivado_perc['fator_desconto_DV100_old'],
titprivado_perc['fator_desconto_DV100'])
titprivado_perc[
'dif_perc'] = titprivado_perc['dif_new'] / titprivado_perc['pu']
# titprivado_perc['mtm'] = np.where(titprivado_perc['dif_perc']>0.10,titprivado_perc['pu'],titprivado_perc['mtm'])
# Cálculo do DV100
titprivado_perc = titprivado_perc.append(aux)
titprivado_perc[
'DV100'] = titprivado_perc['mtm'] - titprivado_perc['mtm_DV100']
# Cálculo do perc_mtm
titprivado_perc[
'perc_mtm'] = titprivado_perc['pv'] / titprivado_perc['mtm']
# Cálculo da duration
titprivado_perc[
'duration'] = titprivado_perc['perc_mtm'] * titprivado_perc['prazo_du']
x = titprivado_perc[['codigo_isin',
'duration']].groupby(['codigo_isin']).agg(['sum'])
x = x.reset_index(level=None,
drop=False,
inplace=False,
col_level=0,
col_fill='')
x1 = pd.DataFrame(columns=['codigo_isin', 'duration'])
x1['codigo_isin'] = x['codigo_isin']
x1['duration'] = x['duration']
del titprivado_perc['duration']
titprivado_perc = titprivado_perc.merge(x1, on=['codigo_isin'], how='left')
titprivado_perc[[
'codigo_isin', 'pu', 'mtm', 'dt_ref', 'mtm_old', 'dif_new', 'dif_old',
'duration', 'spread'
]].to_excel(writer, 'conclusao_fluxo')
titprivado_perc[
titprivado_perc.dt_ref == titprivado_perc.data_referencia][[
'codigo_isin', 'pu', 'mtm', 'dt_ref', 'mtm_old', 'dif_new',
'dif_old', 'duration', 'spread'
]].to_excel(writer, 'conclusao_resumido')
finalizacao = titprivado_perc[[
'codigo_isin', 'mtm'
]][titprivado_perc.dt_ref == titprivado_perc.data_referencia].copy()
del titprivado_perc['fator_desconto_DV100_old']
del titprivado_perc['fator_desconto_old']
del titprivado_perc['mtm_old']
del titprivado_perc['mtm_DV100_N']
del titprivado_perc['pv_DV100_old']
del titprivado_perc['pv_old']
del titprivado_perc['DV100_old']
del titprivado_perc['dif_new']
del titprivado_perc['dif_old']
del titprivado_perc['dif_perc']
writer.save()
# Alteração de formato das colunas que são int e foram lidas como float (sabe lá pq...)
# id_mtm_titprivado
titprivado_perc['id_mtm_titprivado'] = titprivado_perc[
'id_mtm_titprivado'].astype(int)
# id_bmf_numeraca
aux = titprivado_perc[[
'id_papel', 'id_bmf_numeraca'
]][titprivado_perc.id_bmf_numeraca.notnull()].copy()
aux['id_bmf_numeraca'] = aux['id_bmf_numeraca'].astype(int)
del titprivado_perc['id_bmf_numeraca']
aux = aux.drop_duplicates()
titprivado_perc = titprivado_perc.merge(aux, on=['id_papel'], how='left')
# pagto_amortizacao
aux = titprivado_perc[[
'id_papel', 'indexador_dc_du'
]][titprivado_perc.indexador_dc_du.notnull()].copy()
aux['indexador_dc_du'] = aux['indexador_dc_du'].astype(int)
del titprivado_perc['indexador_dc_du']
aux = aux.drop_duplicates()
titprivado_perc = titprivado_perc.merge(aux, on=['id_papel'])
# juros_cada
aux = titprivado_perc[['id_papel', 'juros_cada'
]][titprivado_perc.juros_cada.notnull()].copy()
aux['juros_cada'] = aux['juros_cada'].astype(int)
del titprivado_perc['juros_cada']
aux = aux.drop_duplicates()
titprivado_perc = titprivado_perc.merge(aux, on=['id_papel'], how='left')
# indexador_dc_du
aux = titprivado_perc[[
'id_papel', 'indexador_dc_du'
]][titprivado_perc.indexador_dc_du.notnull()].copy()
aux['indexador_dc_du'] = aux['indexador_dc_du'].astype(int)
del titprivado_perc['indexador_dc_du']
aux = aux.drop_duplicates()
titprivado_perc = titprivado_perc.merge(aux, on=['id_papel'])
# juros_dc_du
aux = titprivado_perc[['id_papel', 'juros_dc_du'
]][titprivado_perc.juros_dc_du.notnull()].copy()
aux['juros_dc_du'] = aux['juros_dc_du'].astype(int)
del titprivado_perc['juros_dc_du']
aux = aux.drop_duplicates()
titprivado_perc = titprivado_perc.merge(aux, on=['id_papel'])
# flag_inclusao
titprivado_perc['flag_inclusao'] = titprivado_perc['flag_inclusao'].astype(
int)
# du_per
titprivado_perc['du_per'] = titprivado_perc['du_per'].astype(int)
# dc_per
titprivado_perc['dc_per'] = titprivado_perc['dc_per'].astype(int)
# dt_ref -> data_fim
titprivado_perc['dt_ref'] = pd.to_datetime(titprivado_perc['dt_ref'])
titprivado_perc['data_fim'] = np.where(
titprivado_perc['indexador'] == 'DI1',
titprivado_perc['dt_ref'] - pd.DateOffset(months=0, days=1),
titprivado_perc['dt_ref'])
titprivado_perc['id_papel'] = titprivado_perc['id_papel_old']
titprivado_perc['data_mtm'] = titprivado_perc['data_referencia']
titprivado_perc['data_negociacao'] = titprivado_perc['data_referencia']
# Tabelas não necessárias - MTM
del titprivado_perc['data_referencia']
del titprivado_perc['id_papel_old']
del titprivado_perc['indice_du_mtm']
del titprivado_perc['indice_dc_mtm']
del titprivado_perc['ano_dt_ref2']
del titprivado_perc['mes_dt_ref2']
del titprivado_perc['dia_dt_ref2']
del titprivado_perc['vertices_positivo']
del titprivado_perc['indice_dc_dt_ref2']
del titprivado_perc['indice_du_dt_ref2']
del titprivado_perc['prazo_dc']
del titprivado_perc['ano_inicio']
del titprivado_perc['mes_inicio']
del titprivado_perc['dia_inicio']
del titprivado_perc['indice_du_inicio']
del titprivado_perc['indice_dc_inicio']
del titprivado_perc['ano_fim']
del titprivado_perc['mes_fim']
del titprivado_perc['dia_fim']
del titprivado_perc['indice_du_fim']
del titprivado_perc['indice_dc_fim']
del titprivado_perc['dt_ref']
del titprivado_perc['dtoperacao_mtm']
del titprivado_perc['dif']
del titprivado_perc['pu_mercado']
del titprivado_perc['pu_curva']
del titprivado_perc['mtm_mercado']
del titprivado_perc['mtm_curva']
del titprivado_perc['pu_regra_xml']
del titprivado_perc['mtm_regra_xml']
del titprivado_perc['data_spread']
del titprivado_perc['pu']
del titprivado_perc['dif_curva']
del titprivado_perc['pupar']
del titprivado_perc['indice_du_fim_spread']
del titprivado_perc['indice_du_inicio_spread']
del titprivado_perc['prazo_du_spread']
del titprivado_perc['mtm_spread']
del titprivado_perc['pv_spread']
del titprivado_perc['tx_spot_spread']
del titprivado_perc['tx_spot_ano_spread']
del titprivado_perc['fator_desconto_spread']
# Tabelas não necessárias - XML
del titprivado_perc['id_xml_debenture']
del titprivado_perc['isin']
del titprivado_perc['coddeb']
del titprivado_perc['dtemissao']
del titprivado_perc['dtoperacao']
del titprivado_perc['dtvencimento']
del titprivado_perc['cnpjemissor']
del titprivado_perc['qtdisponivel']
del titprivado_perc['qtgarantia']
del titprivado_perc['pucompra']
del titprivado_perc['puvencimento']
del titprivado_perc['puposicao']
del titprivado_perc['puemissao']
del titprivado_perc['principal']
del titprivado_perc['tributos']
del titprivado_perc['valorfindisp']
del titprivado_perc['valorfinemgar']
del titprivado_perc['coupom']
del titprivado_perc['percindex']
del titprivado_perc['caracteristica']
del titprivado_perc['percprovcred']
del titprivado_perc['classeoperacao']
del titprivado_perc['idinternoativo']
del titprivado_perc['nivelrsc']
del titprivado_perc['header_id']
del titprivado_perc['cusip']
del titprivado_perc['depgar']
del titprivado_perc['debconv']
del titprivado_perc['debpartlucro']
del titprivado_perc['SPE']
del titprivado_perc['dtretorno']
del titprivado_perc['puretorno']
del titprivado_perc['indexadorcomp']
del titprivado_perc['perindexcomp']
del titprivado_perc['txoperacao']
del titprivado_perc['classecomp']
# Remove as duplicatas de isin
titprivado_perc = titprivado_perc.sort(
['codigo_isin', 'id_papel', 'data_fim'], ascending=[True, True, True])
titprivado_perc = titprivado_perc.drop_duplicates(
subset=['codigo_isin', 'data_fim'])
# titprivado_perc['data_bd'] = horario_bd
titprivado_perc['data_bd'] = datetime.datetime.today()
titprivado_perc = titprivado_perc.where((pd.notnull(titprivado_perc)),
None)
titprivado_perc['flag1'] = titprivado_perc['flag'].str[0:2]
del titprivado_perc['flag']
titprivado_perc = titprivado_perc.rename(columns={'flag1': 'flag'})
logger.info("Conectando no Banco de dados")
connection = db.connect('localhost',
user='******',
passwd='root',
db='projeto_inv',
use_unicode=True,
charset="utf8")
logger.info("Conexão com DB executada com sucesso")
logger.info("Salvando base de dados - mtm_renda_fixa")
pd.io.sql.to_sql(titprivado_perc,
name='mtm_renda_fixa',
con=connection,
if_exists='append',
flavor='mysql',
index=0)
#Fecha conexão
connection.close()
logger.info("Preenchimento tabela xml")
# 9 - Preenchimento tabela xml
del original['id_xml_debenture']
del original['pu_mercado']
del original['mtm_mercado']
del original['pu_curva']
del original['mtm_curva']
del original['pu_regra_xml']
del original['mtm_regra_xml']
del original['data_referencia']
del titprivado['mtm']
titprivado = titprivado.merge(finalizacao, on=['codigo_isin'], how='left')
titprivado_xml = titprivado[titprivado.dt_ref ==
titprivado.data_referencia].copy()
titprivado_xml = titprivado_xml.drop_duplicates(subset=['id_papel'],
take_last=True)
titprivado_xml = titprivado_xml.rename(columns={'mtm': 'mtm_calculado'})
anbima_deb = anbima_deb.rename(columns={'pu': 'pu_n'})
titprivado_xml = titprivado_xml.merge(anbima_deb,
on=['coddeb', 'data_spread'],
how='left')
titprivado_xml['pu'] = np.where(titprivado_xml['pu_n'].notnull(),
titprivado_xml['pu_n'],
titprivado_xml['mtm_calculado'])
titprivado_xml['pu_mercado'] = np.where(
titprivado_xml['caracteristica'] == 'N', titprivado_xml['pu'], 0)
titprivado_xml['pu_curva'] = np.where(
titprivado_xml['caracteristica'] == 'V', titprivado_xml['pupar'], 0)
titprivado_xml = titprivado_xml[[
'id_papel', 'pu_mercado', 'pu_curva', 'data_referencia'
]].copy()
final = original.merge(titprivado_xml, on=['id_papel'], how='left')
final['data_referencia'] = dt_base_rel
final['pu_mercado'] = np.where(
(final['pu_mercado'].isnull()) | (final['pu_mercado'] == 0),
final['puposicao'], final['pu_mercado'])
final['pu_mercado'] = np.where(final['dtretorno'].notnull(),
final['puposicao'], final['pu_mercado'])
final['mtm_mercado'] = final['pu_mercado'] * (final['qtdisponivel'] +
final['qtgarantia'])
final['pu_curva'] = np.where(final['pu_curva'].isnull(),
final['puposicao'], final['pu_curva'])
final['pu_curva'] = np.where(final['dtretorno'].notnull(),
final['puposicao'], final['pu_curva'])
final['mtm_curva'] = final['pu_curva'] * (final['qtdisponivel'] +
final['qtgarantia'])
final['pu_regra_xml'] = np.where(final['caracteristica'] == 'N',
final['pu_mercado'], final['pu_curva'])
final['mtm_regra_xml'] = np.where(final['caracteristica'] == 'N',
final['mtm_mercado'], final['mtm_curva'])
final['data_bd'] = datetime.datetime.today()
del final['dtrel']
final['indexador'] = final['indexador'].str.replace('IGPM', 'IGP')
final['indexador'] = final['indexador'].str.replace('IAP', 'IPC')
final['indexador'] = final['indexador'].str.replace('SEM-ÍNDICE', 'PRE')
final['indexador'] = final['indexador'].str.replace('ANB', 'DI1')
final['indexador'] = final['indexador'].str.replace('ANBID', 'DI1')
final['indexador'] = final['indexador'].str.replace('CDI', 'DI1')
final['indexador'] = final['indexador'].str.replace('IPCA', 'IPC')
logger.info("Conectando no Banco de dados")
connection = db.connect('localhost',
user='******',
passwd='root',
db='projeto_inv',
use_unicode=True,
charset="utf8")
logger.info("Conexão com DB executada com sucesso")
logger.info("Salvando base de dados - xml_debenture")
pd.io.sql.to_sql(final,
name='xml_debenture',
con=connection,
if_exists='append',
flavor='mysql',
index=0)
#Fecha conexão
connection.close()
def upload_manual_cotas(query, columns, table):
import os
import pandas as pd
import pymysql as db
import datetime
import numpy as np
import logging
from findt import FinDt
from dependencias.Metodos.funcoes_auxiliares import full_path_from_database
logger = logging.getLogger(__name__)
# Definindo os paths
path_feriados = full_path_from_database(
"feriados_nacionais") + "feriados_nacionais.csv"
path_cotas = full_path_from_database("bloomberg_cotas")
#Criação série diária
logger.info("Tratando dados")
#Seleciona o última dia do mês vigente
mesfim = datetime.date.today().month
fim = datetime.date(datetime.date.today().year, mesfim, 1) - pd.DateOffset(
months=0, days=1)
dt_ref = pd.date_range(start='01/01/1996', end=fim, freq='D').date
ano = pd.date_range(start='01/01/1996', end=fim, freq='D').year
mes = pd.date_range(start='01/01/1996', end=fim, freq='D').month
dias = pd.date_range(start='01/01/1996', end=fim, freq='D').day
serie_dias = pd.DataFrame(columns=['dt_ref', 'ano', 'mes', 'dia'])
serie_dias['dt_ref'] = dt_ref
serie_dias['ano'] = ano
serie_dias['mes'] = mes
serie_dias['dia'] = dias
# Identificar se é dia útil
dt_max = max(serie_dias['dt_ref'])
dt_min = min(serie_dias['dt_ref'])
per = FinDt.DatasFinanceiras(dt_min, dt_max, path_arquivo=path_feriados)
du = pd.DataFrame(columns=['dt_ref'])
du['dt_ref'] = per.dias(3)
du['du_1'] = 1
serie_dias = serie_dias.merge(du, on=['dt_ref'], how='left')
serie_dias['du_1'] = serie_dias['du_1'].fillna(0)
serie_dias['dc_1'] = 1
# Calculo de dias corridos por mes
serie_dias_group_count = serie_dias[['dt_ref', 'ano',
'mes']].groupby(['ano', 'mes'
]).agg(['count'])
serie_dias_group_count = serie_dias_group_count.reset_index(level=None,
drop=False,
inplace=False,
col_level=0,
col_fill='')
serie_dias_group_count_filter = pd.DataFrame(columns=['ano', 'mes', 'dc'])
serie_dias_group_count_filter['ano'] = serie_dias_group_count['ano']
serie_dias_group_count_filter['mes'] = serie_dias_group_count['mes']
serie_dias_group_count_filter['dc'] = serie_dias_group_count['dt_ref']
serie_dias = serie_dias.merge(serie_dias_group_count_filter,
on=['ano', 'mes'],
how='left')
#calculo de dias uteis por mes
serie_dias_group_sum = serie_dias[['du_1', 'ano',
'mes']].groupby(['ano',
'mes']).agg(['sum'])
serie_dias_group_sum = serie_dias_group_sum.reset_index(level=None,
drop=False,
inplace=False,
col_level=0,
col_fill='')
serie_dias_group_sum_filter = pd.DataFrame(columns=['ano', 'mes', 'du'])
serie_dias_group_sum_filter['ano'] = serie_dias_group_sum['ano']
serie_dias_group_sum_filter['mes'] = serie_dias_group_sum['mes']
serie_dias_group_sum_filter['du'] = serie_dias_group_sum['du_1']
serie_dias = serie_dias.merge(serie_dias_group_sum_filter,
on=['ano', 'mes'],
how='left')
#Criação da série de cotas
lista_cotas = os.listdir(path_cotas)
lista_cotas = [x for x in lista_cotas if "~" not in x]
cotasdf = pd.DataFrame()
for i in lista_cotas:
leitura = pd.read_excel(path_cotas + '/' + i)
leitura = leitura.rename(
columns={
'Date': 'dt_ref',
'FUND_NET_ASSET_VAL': 'cota',
'FUND_TOTAL_ASSETS': 'pl'
})
leitura['isin_fundo'] = i
cotasdf = cotasdf.append(leitura)
cotasdf['isin_fundo'] = cotasdf['isin_fundo'].str.split('.')
cotasdf['isin_fundo'] = cotasdf['isin_fundo'].str[0]
cotasdf['dt_ref'] = cotasdf['dt_ref'].astype(str)
cotasdf['dt_ref'] = cotasdf['dt_ref'].str.split('-')
cotasdf['ano'] = cotasdf['dt_ref'].str[0]
cotasdf['mes'] = cotasdf['dt_ref'].str[1]
cotasdf['dia'] = cotasdf['dt_ref'].str[2]
cotasdf['dt_ref'] = pd.to_datetime(cotasdf['ano'] + cotasdf['mes'] +
cotasdf['dia']).dt.date
del cotasdf['ano']
del cotasdf['mes']
del cotasdf['dia']
logger.info("Conectando no Banco de dados")
connection = db.connect('localhost',
user='******',
passwd='root',
db='projeto_inv')
logger.info("Conexão com DB executada com sucesso")
cnpj = pd.read_sql_query(query, connection)
logger.info("Leitura do banco de dados executada com sucesso")
cnpj['cnpjfundo_outros'] = np.where(cnpj['cnpjfundo_outros'].isnull(),
cnpj['cnpjfundo_1nivel'],
cnpj['cnpjfundo_outros'])
cnpj['cnpj'] = cnpj['cnpjfundo_outros']
del cnpj['cnpjfundo_1nivel']
del cnpj['cnpjfundo_outros']
cnpj = cnpj.drop_duplicates()
cotasdf = pd.merge(cotasdf,
cnpj,
left_on='isin_fundo',
right_on='isin',
how='left')
del cotasdf['isin']
cotasdf = cotasdf.rename(columns=columns)
cotasdf['data_bd'] = datetime.datetime.today()
logger.info("Salvando base de dados")
pd.io.sql.to_sql(cotasdf,
name=table,
con=connection,
if_exists="append",
flavor='mysql',
index=0,
chunksize=5000)
connection.close()
take_last=False)
cen1['indexador_shift'] = cen1['indexador_cod'].shift()
cen1['prazo_shift'] = cen1['prazo'].shift()
cen1['tx_spot_shift'] = cen1['tx_spot'].shift()
cen1['dif'] = np.where((cen1.indexador_cod == cen1.indexador_shift) &
(cen1.prazo == cen1.prazo_shift),
cen1.tx_spot - cen1.tx_spot_shift, 'NaN')
cen2 = cen1[cen1.dif != 'NaN']
#________________________________________________________________________________________________________
# GERACAO DE SERIE DE DIAS ÚTEIS E DIAS CORRIDOS
ano = start[0:4]
mes = start[5:7]
dia = start[8:10]
dt_inicio = dia + '-' + mes + '-' + ano
dt_max = max(tp_expo['dt_vencto'])
per = FinDt.DatasFinanceiras(dt_inicio, dt_max, path_arquivo=feriados_sheet)
du = pd.DataFrame(columns=['data_ref'])
dc = pd.DataFrame(columns=['data_ref'])
dc['data_ref'] = per.dias()
dc['flag_dc'] = 1
du['data_ref'] = per.dias(3)
du['flag_du'] = 1
serie_dias = pd.merge(dc,
du,
left_on=['data_ref'],
right_on=['data_ref'],
how='left')
serie_dias['flag_du'] = serie_dias['flag_du'].fillna(0)
serie_dias['indice_dc'] = np.cumsum(serie_dias['flag_dc'])
serie_dias['indice_du'] = np.cumsum(serie_dias['flag_du'])
del serie_dias['flag_du']