portfolio_builder.py

Script-chave que monta a base base_portfolios.xlsx, atualiza base_carteira_online_v12.xlsx e hist_risk_metrics.xlsx.

A descrição detalhada do pipeline de atualização da carteira online pode ser acessada aqui.

PortfolioBuilder

Source code in carteira_online/production/portfolio_builder.py

class PortfolioBuilder:

    def __init__(self, today=dt.date.today()):

        self.is_develop_branch = os.path.basename(os.getcwd()).split("_")[-1] == "develop"
        self.today = today#dt.date(2023,2,22)#today


        # padronizado para cd .. root folder -> os.pardir
        self.onedrive_path = os.pardir

        # hexadecimal das cores disponiveis
        self.colors = {
            "azul_escuro" : "#0f00ff",
            "azul_claro" : "#0091ff",
            "marrom" : "#7B3214",
            "verde" : "#04a200",
            "amarelo" : "#e5b900",
            "cinza" : "#a6b5c1",
            "vermelho" : "#ff0014",
            "vinho" : "#904451",
        }

        # Define a cor que cada grupo de ativos terá
        self.color_map = {
            "ações"      : self.colors["azul_escuro"],
            "termo"      : self.colors["vermelho"],
            "caixa"      : self.colors["cinza"],
            "caixa_us"   : self.colors["cinza"],
            "swap"       : self.colors["azul_escuro"],
            "futuro"     : self.colors["azul_escuro"],
            "fut_dol"    : self.colors["azul_escuro"],
            "fundos"     : self.colors["verde"],
            "fundos_fia" : self.colors["azul_claro"],
            "rf_privada" : self.colors["vinho"],
            "loan"       : self.colors["azul_escuro"],
            "vc"         : self.colors["amarelo"],
            "vc agro"    : self.colors["marrom"],
            "cambio"     : self.colors["azul_escuro"],
            "metricas"   : self.colors["azul_escuro"],
            "fundo_vc"   : self.colors["azul_escuro"],
            "spac"       : self.colors["azul_claro"],
            "trade rv"   : self.colors["azul_escuro"],
            "margin"     : self.colors["azul_escuro"],
            "swap_eurusd": self.colors["azul_escuro"],
            "forward"    : self.colors["azul_escuro"],
            "interest"           : self.colors["azul_escuro"],
            "currency coupon"    : self.colors["azul_escuro"],
            "luxor"      : self.colors["azul_escuro"],
            "ntnb"       : self.colors["cinza"],
            "bmf"        : self.colors["azul_escuro"],
            "curncy"        : self.colors["azul_escuro"],
            "ndf"          : self.colors["cinza"],
            "fx"          : self.colors["cinza"],
            "private equity" : self.colors["amarelo"],
            "benchmark" : self.colors["cinza"],
            "margin cash": self.colors["vermelho"],
            "equity_fund" : self.colors["azul_claro"],
            "taxas e custos"   : self.colors["cinza"],
            "cripto"   : self.colors["cinza"],

        }

        # Define a ordem das divisoes do
        # grafico (com base na coluna grupo)
        # 1-ações, 2-spacs, 3-fundos_3os, 4-vc,
        # 5-loan,caixa e swap
        # -> Quanto mais negativo, mais no
        # topo aparecerá
        self.order_modifiers = {
            "ações"      : -9_000000000,
            "termo"      : -6_000000000,
            "caixa"      : -2_000000000,
            "caixa_us"   : -2_000000000,
            "swap"       : -2_000000000,
            "futuro"     : -2_000000000,
            "fut_dol"    : -2_000000000,
            "fundos"     : -7_000000000,
            "fundos_fia" : -8_000000000,
            "rf_privada" : -4_000000000,
            "loan"       : -3_000000000,
            "vc"         : -5_000000000,
            "vc agro"    : -1_000000000,
            "cambio"     : -3_000000000,
            "metricas"   : 0,
            "fundo_vc"   : -9_000000000,
            "spac"       : -8_000000000,
            "spac_w"     : -8_000000000,
            "trade rv"   : 0,
            "margin"     : -2_000000000,
            "swap_eurusd": -2_000000000,
            "forward"    : -2_000000000,
            "interest"           : -1_000000000,
            "currency coupon"    : -1_000000000,
            "luxor"      : -9_000000000,
            "ntnb"       : -2_000000000,
            "bmf"       : -3_000000000,
            "curncy"       : -3_000000000,
            "ndf"       : -3_000000000,
            "fx"       : -3_000000000,
            "private equity"       : -5_000000000,
            "benchmark" : -2_000000000,
            "margin cash" : -3_000000000,
            "equity_fund" : -8_000000000,
            "taxas e custos"   : -2_000000000,
            "cripto"   : -1_000000000,
        }

        # alguns agrupamentos de nomes para facilitar edicoes futuras
        # -> Todo novo fundo do portfolio devera ser inserido nos grupos certos abaixo
        self.fund_names = {
            "luxor_ptf" : ["fund_a", "all_eqt", "all_eqt_acoes", "lipizzaner", "mangalarga_fic_fia", "maratona"],

            "all" : ["fund_a", "all_eqt", "all_eqt_acoes", "lipizzaner", "lipizzaner_acoes", "mangalarga_fic_fia",
                     "fund_a_ex_vc", "fund_b", "fund_b_ex_vc", "hmx",
                     "hmx_ex_vc", "edel_lipi", "edel_lipi_acoes", "maratona", "maratona_acoes", "mrtn_hmx"],

            "partial" : ["fund_a_ex_vc", "lipizzaner_acoes", "fund_b_ex_vc", "hmx_ex_vc",
                         "all_eqt_acoes", "edel_lipi_acoes", "maratona_acoes"],

            "vc_funds": ["fund_a", "fund_b","hmx"],

            "vc_funds_all" : ["fund_a", "all_eqt", "all_eqt_acoes", "lipizzaner", "hmx", "fund_b", "edel_lipi", "edel_lipi_acoes", "mangalarga_fic_fia", "mrtn_hmx"],

            "trading" : ["lipizzaner_acoes", "fund_a_ex_vc", "fund_b_ex_vc", "hmx_ex_vc", "maratona_acoes"],

            "dol_hedge" : ["lipizzaner", "lipizzaner_acoes", "edel_lipi", "edel_lipi_acoes", "maratona_acoes", "mrtn_hmx"],

            "onshore" : ["lipizzaner", "mangalarga fic fia", "maratona"],

            "offshore" : ["fund a", "fund b", "hmx"],

            "simulated" : ["all_eqt", "all_eqt_acoes", "edel_lipi_acoes", "edel_lipi", "mrtn_hmx"],

            "iliquids_funds" : ["fund_a", "all_eqt", "all_eqt_acoes", "lipizzaner", "mangalarga_fic_fia", "maratona", 
                                "fund_b", "hmx", "edel_lipi", "mrtn_hmx"],

        }

        self.partial_to_complete_name_map = {
            "fund_a_ex_vc" : 'fund_a', "lipizzaner_acoes" : "lipizzaner", "fund_b_ex_vc" : 'fund_b', "hmx_ex_vc" : 'hmx',
                         "all_eqt_acoes" : 'lipizzaner', "edel_lipi_acoes" : 'edel_lipi', "maratona_acoes": 'maratona'
        }

        # criando modulos para extracao de dados do mercado e do btg

        self.query_mngr = LuxorQuery(is_develop_mode=False)

        self.data_extractor = adex.AssetDataExtractor(onedrive_path=self.onedrive_path, query_mngr=self.query_mngr,today=self.today)

        self.yesterday = self.query_mngr.get_bday_offset(self.today, offset=-1, location="all")

        # Fixando nomes de arquivos e diretorios usado
        # s
        self.input_bases_dir = Path("bases_input")
        self.input_base_file = "input_data.xls"

        #self.assets_base_name = "assets_script_input.xlsx"
        #self.funds_base_name = "fundos_script_input.xlsx"

        self.program_running = True


    def build(self):

        # Cotacao do dolar atual
        self.USD_BRL = self.query_mngr.get_price("usdbrl curncy", px_date=self.today)

        # Carregando base de ativos
        self.assets_db = self.__load_assets_base(self.input_base_file)

        # Definindo as cores de cada ativo
        self.assets_db = self.__set_color_hex(self.assets_db)

        # -> A forma de pegar os precos pode ser a mesma
        self.funds_db = self.__load_funds_base(self.input_base_file)

        # Juntando as colunas dos dados carregados em uma tabela apenas
        merged_data = self.merge_data(self.assets_db, self.funds_db)

        logger.info(f"Dólar: {self.USD_BRL}")
        # Preencher coluna de precos
        merged_data = self.populate_prices_BBG(merged_data)

        # Pegar os caixas. Sera gerado um df com caixa pra cada fundo 
        # Precisa ser feito depois de pegar os precos, para nao sobrescrever
        merged_data = self.get_caixas(merged_data)

        # caixas calculados, removemos trades_rv da base
        merged_data = merged_data.drop(merged_data[merged_data["Grupo"] == "trade rv"].index)

        # Preencher com localizacao do investimento: onshore ou offshore
        merged_data = self.populate_location(merged_data)

        # Calcular valor de mercado de cada ativo
        merged_data = self.calculate_MktVal(merged_data)

        # Ajustar cor dos negativos(short) 
        merged_data = self.__update_colors(merged_data)

        # Separar bases dos fundos nos fundos como queremos olhar
        self.funds = self.segregate_funds(merged_data)
        print(self.funds["lipizzaner"].columns)

        # Computar os pls de cada base segregada
        self.pls = self.get_pls(self.funds)
        # DEBUG:
        #print()
        #logger.info(self.pls)

        # Calcular percentuais, dividindo Mkt_val pelo pl respectivo
        self.funds = self.calculate_percentages(self.funds, self.pls)


        #self.calculate_day_attr(self.funds)
        self.funds = self.set_date_and_usdbrl(self.funds)

        # Gera output da base total com todos os ativos discriminados
        self.save_portfolio_full_database(self.funds)

        #self.non_groupable_vcs = self.get_non_groupable_vcs(self.funds)
        self.non_groupable_iliquids = self.get_non_groupable_iliquids(self.funds)

        self.non_groupable_iliquids_managers = self.get_non_groupable_iliquids_managers(self.funds)

        # -> Agrupar os vcs (regra < 1%)
        #self.funds = self.group_vcs(self.funds, self.non_groupable_vcs)
        self.funds = self.group_iliquids(self.funds, self.non_groupable_iliquids_managers)

        self.risk_df = self.compute_risk_metrics(self.funds)

        # Agrupa os ativos com mesmo nome, alterando o nome mostrado
        self.process_assets_concat(self.funds)

        # Ajustando as cores mais uma vez, pois pode virar positivo/negativo após agregacao
        for fund_name, fund_df in self.funds.copy().items():
            self.funds[fund_name] = self.__update_colors(fund_df)

        self.funds = self.define_assets_order(self.funds)

        # Salvando dados tratados para geracao do relatorio
        self.dfs_to_save = self.funds
        self.dfs_to_save["Metricas de Risco"] = self.risk_df
        self.dfs_to_save["Info Execuções"] = self.__create_exec_info()
        self.dfs_to_save["Lipi Investors"] = self.__create_lipi_investors_table()
        fund_info_df = pd.DataFrame({"Fundo" : list(self.pls.keys()), "PL" : list(self.pls.values())})
        self.dfs_to_save["Info Fundos"] = fund_info_df
        self.dfs_to_save["Changes"] = self.compute_positions_variation()
        self.dfs_to_save["Metrics_changes"] = self.compute_metrics_variation()

        self.save_portfolio(self.dfs_to_save)
        self.save_portfolio_risk_metrics()


    def __load_assets_base(self, filename):
        try:

            data = pd.read_excel(self.input_bases_dir/filename, sheet_name="Ativos")
            data = data[ data.columns[:8] ]     # Selecionando 8 primeiras colunas
            data = data[data["Asset"].notna()]  # Ignora rows na (ativos nao lancados)

            # garantindo remocao da coluna de preços e location
            data = data.iloc[:, 0:6]

            # converte todo o texto para lower case
            data = data.apply(lambda x: x.astype(str).str.lower())

            # removendo espacos em branco no inicio e no fim de cada texto
            data = data.apply(lambda row: row.str.strip())

            # cria uma coluna de precos sem dados ainda
            data["Price"] = np.nan

            return data

        except FileNotFoundError:
            logger.error(f"Arquivo {filename} não encontrado em {self.input_bases_dir}")
            logger.error("Finalizando...")
            sys.exit()

    def __set_color_hex(self, data):
        colors = []

        for idx, row in data.iterrows():
            color_key = row["Grupo"] if row["Tipo"] not in ["spac", "spac_w"] else row["Tipo"][:4]
            colors.append(self.color_map[color_key])

        data["Cor"] = colors

        return data


    def __update_colors(self, data):
        """Atualiza a cor com base em algum criterio.
        Por enquanto, apenas coloca como vermelho se o
        market value for negativo.
        """
        for idx, row in data.iterrows():
            if row["Mkt_Value"] < 0:
                data.loc[idx, "Cor"] = self.colors["vermelho"]
            else:
                data.loc[idx, "Cor"] = self.color_map[row["Grupo"]]

        return data


    def __load_funds_base(self, filename):
        """
            Carrega base de dados com as carteiras dos fundos.
            Concatena todas numa tabela só.
            Args:
                file_name (str): caminho para arquivo .xlsx

            Returns:
                Dataframe de pandas
        """
        try:
            data = pd.read_excel(self.input_bases_dir/filename, sheet_name=["Lipizzaner", "Fund A", "Fund B", "HMX", "Mangalarga FIC", "Maratona"])        

            # tratando dados:
            for k, v in data.items():
                data[k] = v[ v.columns[:4] ].dropna(how="any")
                data[k] = data[k].loc[ ((data[k]["Quantidade"] != 0) | (data[k]["Ticker"] == "Caixa (a receber)")), :]

            # caixa a receber
            f_data = data["Fund A"]
            idx_mod = f_data.loc[((f_data["Asset"] == "Caixa (a receber)") & (f_data["Ticker"] == "Caixa (a receber)"))].index[0]

            f_data.at[idx_mod, "Quantidade"] = 0/self.USD_BRL
            data["Fund A"] = f_data.copy()

            f_data = data["Lipizzaner"]
            idx_mod = f_data.loc[((f_data["Asset"] == "Caixa (a receber)") & (f_data["Ticker"] == "Caixa (a receber)"))].index[0]
            f_data.at[idx_mod, "Quantidade"] = 0/self.USD_BRL # global vai multiplicar pelo mesmo dolar depois e netar
            data["Lipizzaner"] = f_data.copy()

            # Seguiremos com os dados concatenados para facilitar por enquanto
            data = pd.concat(data.values(), ignore_index=True)

            # Antes de converter para lower case, copiar coluna Assets
            assets_copy = data["Asset"]
            # converte todo o texto para lower case
            data = data.apply(lambda row: row.astype(str).str.lower())

            # remove espacos em branco do inicio e do fim de cada entrada
            data = data.apply(lambda row: row.str.strip())

            # coluna quantidade precisa ser reconvertida para numerico
            try:
                data["Quantidade"] = pd.to_numeric(data["Quantidade"]).round(8)
            except:
                logger.error("Voce errou, humano.")
                logger.error("Tem texto onde era pra ter quantidade.")
                logger.error(data["Quantidade"])
                data.to_excel("error.xlsx")
                sys.exit()

            # Inserindo coluna com nomes personalizavel
            data["Nome"] = assets_copy
            data["Nome"] = data["Nome"].apply(lambda x: x.replace(" |", "|").replace("| ", "|"))

            cols = ["Nome"] + [col for col in data.columns if col != "Nome"]

            data = data[cols]

            return data

        except FileNotFoundError:
            logger.error(f"Arquivo {filename} não encontrado em {self.input_bases_dir}")
            logger.error("Finalizando...")
            sys.exit()


    def merge_data(self, assets_data, funds_data):
        """Realiza junção interna sobre as colunas 'Asset' e 'Ticker'
        Args:
            assets_data (Pandas Dataframe): Base com dados dos ativos
            funds_data (Pandas Dataframe): Base com dados dos fundos

        Returns:
            Pandas Dataframe: Base com os dados unificados
        """
        data = pd.merge(funds_data, assets_data,
                         how="inner", on=["Asset","Ticker"])
        return data


    def populate_prices_BBG(self, data):
        """Popula a coluna 'Prices' com o preco atual de cada ativo.
            Se nao for aplicavel, preenche com valor 1.

        Args:
            data: Dataframe de pandas com dados da carteira e ativos
                  concatenados
        Returns:
            Dataframe de pandas com coluna de preços preenchida
        """

        def __get_price(row):
            # Função auxiliar para preencher condicionalmente
            swaps_zerados = True
            # se nao tem ticker bbg, preco valera 1
            if row["Ticker_BBG"] == "nan": 
                # TODO calculos das metricas internamente
                if row["Grupo"] == "metricas":
                    return 0

                if row["Grupo"] == "swap":
                    if row["Fundo"].lower() == "maratona":
                        return 1
                    # Se for swap, retorna o p&l
                    if row["Tipo"] == "swap_p&l":
                        if "liq" in row["Ticker"]:
                            return 1
                        if swaps_zerados : return 0
                        #else:
                            # 
                        return self.data_extractor.get_swap_pnl(row["Fundo"].title())

                    elif row["Tipo"] == "swap_exp":
                        if swaps_zerados : return 0 # ALTERAR PARA PEGAR METRICA DE EXPOSICAO

                        return self.data_extractor.get_swap_exp(row["Fundo"].title())

                #ip_atlas= "Outrigger Fund Ltd - IP Atlas USD Equity Class - Subclass B".lower()
                #if row["Ticker"] == ip_atlas:
                #    return 1000

                if row["Grupo"] == 'termo':
                    # Vamos pegar o preco medio da execucao, que eh o preco do termo fixo
                    try:
                        df = self.query_mngr.get_table("last_positions_by_bank")
                        ticker = row["Ticker"].lower()

                        price = df.query("Ticker == @ticker").tail(1)["Avg_price"].squeeze()
                        return -price
                    except:
                        logger.error(f"Erro ao buscar preco do termo {ticker}")
                        pass

                price = self.query_mngr.get_price(row["Ticker"], px_date=self.today)
                if price == 0 or price is None: #Nao encontrado
                    price = 1

                #if row["Grupo"] == "termo":
                #    price = -price

                return price

            else:

                price = self.query_mngr.get_price(row["Ticker_BBG"])
                #if row["Ticker_BBG"] == 'lzrfy us equity':
                #    price = self.query_mngr.get_price("rent3 bz equity")
                #    price = price/self.query_mngr.get_price("usdbrl curncy")

                # Preco do contrato de dolar vai ser a variacao de um dia pro outro
                if row["Tipo"] in ["fut_dol", "fut_dol_min"]:
                    px_today = self.query_mngr.get_price(row["Ticker_BBG"])
                    prev_date = self.query_mngr.get_bday_offset(self.today, -1, location="bz")
                    px_prev = self.query_mngr.get_price(row["Ticker_BBG"], px_date=prev_date)
                    size = 50 if row["Tipo"] == "fut_dol" else 10

                    price = (px_today - px_prev) * size

                # Se for bdr, precisaremos ajustar pelo peso
                if row["Tipo"] == "ações_bdr":
                    bdr_ticker = row["Ticker"]
                    peso = self.query_mngr.get_bdr_size(bdr_ticker)


                    #if bdr_ticker == "amzo34 bz equity":
                    #    print("-------> PESO DE AMZO34 ALTERADO NA MAO!!!!!! <-----------")
                    #    peso = peso*20
                    price = price * self.USD_BRL / peso

                # AJUSTES MANUAIS DE PRECO, FAZER AQUI!
                #if row["Ticker"] == "poraque fic fip" and price < 50000:
                #    print(">>>> PREÇO DE OMEGA AJUSTADO MANUALMENTE <<<<")
                #    
                #    price = 216526.697109

                return  price

        data["Price"] = data.apply(lambda row: __get_price(row), axis=1)

        return data


    def get_caixas(self, merged_data):
        cash_calc = cash_calculator.CashCalculator(self.input_bases_dir/self.input_base_file,today=self.today)
        #pegando caixas dos fundos onshore
        #print()
        caixas = {}
        for fund_name in self.fund_names["onshore"]:
            df = merged_data.loc[ merged_data["Fundo"] == fund_name ]
            # setar qtd de termos
            total_termo =  self.query_mngr.get_term_debt(fund_name)

            self.data_extractor.set_term_adj(fund_name, total_termo)

            # setar qtd de futuro e ticker (CONSIDERA-SE QUE TERA APENAS 1 TIPO)
            # TODO: aceitar mais de 1 tipo de futuro
            ticker, qtd_fut = "", 0
            for idx, row in df.loc[ ((df["Tipo"] == "fut_dol") | (df["Tipo"] == "fut_dol_min")) ].iterrows():
                if row["Quantidade"] != 0 :
                    qtd_fut = row["Quantidade"]
                    ticker = row["Ticker"]
                    break
            self.data_extractor.set_fut_data(fund_name, [ticker, qtd_fut])

            trades = df.loc[df["Grupo"] == "trade rv"]
            #caixa = self.data_extractor.get_cx_data(fund_name, trades)
            caixa = cash_calc.get_net_cash(fund_name, trades, data_extractor=self.data_extractor, query_mngr=self.query_mngr, source="onshore")
            caixas[fund_name.replace("_", " ")] = caixa["Caixa"]
            #if fund_name == "global":
            #    caixas[fund_name] -= 4600100 * self.data_extractor.get_usdbrl()
            #if fund_name == "maratona":
            #    caixas[fund_name] = 77760.43

            logger.info(fund_name, caixa)
            logger.info("-- -- -- -- -- -- -- --")

        logger.info("## ## ## ## ## ## ## ## ##")
        # pegando caixas dos fundos offshore
        for fund_name in self.fund_names["offshore"]:
            df = merged_data.loc[ merged_data["Fundo"] == fund_name ]

            trades = df.loc[df["Grupo"] == "trade rv"]
            #caixa = self.data_extractor.get_cx_data(fund_name, trades)
            caixa = cash_calc.get_net_cash(fund_name, trades, data_extractor=self.data_extractor, query_mngr=self.query_mngr, source="offshore")
            caixas[fund_name] = caixa["Caixa"]
            logger.info(fund_name, caixa)
            logger.info("-- -- -- -- -- -- -- --")


        # salvando caixas na base
        def __set_cx(row, cxs):
            fund_name = row["Fundo"]
            # Retornando valor do caixa onshore
            if row["Asset"] == "caixa":
                return cxs[fund_name]
            # Para testar o caixa offshore, olhamos o lipi como fund a
            fund_name = fund_name.replace("lipizzaner", "fund a")
            # Retornando valor do caixa offshore para cada tipo de conta
            if row["Ticker"] in ['us asset account', 'us margin account', 'money market']:#row["Asset"] == "caixa us":
                account_type = row["Ticker"]
                return cxs[fund_name][account_type]

            # Nao eh ativo de caixa, retorna o valor que ja estava
            return row["Price"]

        merged_data["Price"] = merged_data.apply(lambda row: __set_cx(row, caixas), axis=1)

        return merged_data


    def populate_location(self, data):

        def __is_on_off(row):
            # bdrs classificar como Onshore
            if row["Tipo"] == "ações_bdr":
                return "bz"

            exceptions = {
                "meli"  : "us",
                "stone" : "us",
                "xp inc": "us",
                "vc bz" : "us",
                "vc agro" : "us",
            }

            # ETF de S&P precisou sair de exceptions, pois VOO segue a regra padrao
            if (row["Ticker_BBG"] == "ivvb11 bz equity") or ("ivvb11" in row["Ticker"]):
                return "bz"

            if row["Asset"] in exceptions:
                return exceptions[row["Asset"]]
            if row["Tipo"] in exceptions:
                return exceptions[row["Tipo"]]
            # nao caiu numa das excecoes, entao vai ser us
            # apenas se nao for exposto ao real
            return row["Currency Exposure"]

        data["Location"] = data.apply(lambda row: __is_on_off(row), axis=1)

        return data

    def calculate_MktVal(self, data):
        """
        Calcula o valor de mercado de cada ativo em cada fundo base
        """
        def __get_MktVal(row):
            #if row["Grupo"] == "fut_dol":
            #    return 0

            if row["Tipo"] == 'ndf usdbrl':
                # Vai ser calculado pela variacao em relacao ao preco medio *  quantidade
                avg_price = self.query_mngr.get_avg_price(row["Fundo"], row["Asset"]+"_"+row["Ticker"], self.today)
                if avg_price < 0.1 and row["Fundo"] == 'lipizzaner':
                    # ativo esta pelo fund a
                    avg_price = self.query_mngr.get_avg_price('fund a', row["Asset"]+"_"+row["Ticker"], self.today)

                ndf_price = self.query_mngr.get_price(row["Ticker"])

                if row['Fundo'] in self.fund_names["onshore"]:
                    return row["Quantidade"] * (ndf_price-avg_price) # Resultado em BRL
                return row["Quantidade"] * ((ndf_price/avg_price)-1) # Resultado em USD

            if row["Fundo"] in self.fund_names["onshore"]:
                # Nos onshore precisamos corrigir alguns precos pelo dolar
                if row["Location"] == "us" and row["Ticker"] not in ["spx seg hawker jun23", "SPX SEG HAWKER SEP23".lower()]:
                    return row["Quantidade"] * row["Price"] * self.USD_BRL

            return row["Quantidade"] * row["Price"]

        data["Mkt_Value"] = data.apply(lambda row: __get_MktVal(row), axis=1)
        return data


    def segregate_funds(self, data):
        #funds = {
        #    f_name : pd.DataFrame({}, columns=data.columns) for f_name in self.fund_names["all"]
        #}

        check_partial = ["ações", "termo", "swap", #"caixa", "caixa_us","margin",
                        "spacs", "futuro", "fut_dol", "metricas", "fundo_vc", "bmf"]
        check_partial_eqt = check_partial + ["vc", "fundos_fia"]
        check_partial_eqt_acoes = check_partial + ["vc"]

        assets = self.query_mngr.get_table("assets")[["Key", "Luxor_Classification", "Manager"]]

        data["Key"] = data["Asset"] + "_" + data["Ticker"]
        data = pd.merge(data, assets, on="Key", how="left")
        data = data.drop(["Key"], axis=1)
        funds = {
            f_name : pd.DataFrame({}, columns=data.columns) for f_name in self.fund_names["all"]
        }

        for index, row in data.iterrows():

            #if row["Fundo"] == "lipizzaner":
            #    # copiar para o que representa o total
            #    funds["lipi"].loc[len(funds["lipi"])] = row
            #    funds["edel_lipi"].loc[len(funds["edel_lipi"])] = row
            #    # verificar se precisa copiar para o parcial(acoes)
            #    if row["Grupo"] in check_partial:
            #        funds["lipi_acoes"].loc[len(funds["lipi_acoes"])] = row
            #        funds["edel_lipi_acoes"].loc[len(funds["edel_lipi_acoes"])] = row


            if row["Fundo"] == "fund a":
                # copiar para o que representa o total
                funds["fund_a"].loc[len(funds["fund_a"])] = row

                # verificar se precisa copiar para o parcial(ex-vc)
                if (row["Grupo"] in check_partial) and (row["Luxor_Classification"] in ["stocks"]):
                    funds["fund_a_ex_vc"].loc[len(funds["fund_a_ex_vc"])] = row

            elif row["Fundo"] == "fund b":
                # copiar para o que representa o total
                funds["fund_b"].loc[len(funds["fund_b"])] = row
                # verificar se precisa copiar para o parcial(ex-vc)
                if (row["Grupo"] in check_partial) and (row["Luxor_Classification"] in ["stocks"]):
                    funds["fund_b_ex_vc"].loc[len(funds["fund_b_ex_vc"])] = row

                # Adicionando no fund_b + lipi,
                # mas precisa multiplicar pelo dolar
                row["Mkt_Value"] = row["Mkt_Value"] * self.USD_BRL
                funds["edel_lipi"].loc[len(funds["edel_lipi"])] = row
                if (row["Grupo"] in check_partial) and (row["Luxor_Classification"] in ["stocks"]):
                    funds["edel_lipi_acoes"].loc[len(funds["edel_lipi_acoes"])] = row


            elif row["Fundo"] == "hmx":
                # copiar para o que representa o total
                funds["hmx"].loc[len(funds["hmx"])] = row
                # verificar se precisa copiar para o parcial(ex-vc)
                if (row["Grupo"] in check_partial) and (row["Luxor_Classification"] in ["stocks"]):
                    funds["hmx_ex_vc"].loc[len(funds["hmx_ex_vc"])] = row

                # Adicionando no maratona + HMX, mas precisa multiplicar pelo dolar
                row["Mkt_Value"] = row["Mkt_Value"] * self.USD_BRL
                funds["mrtn_hmx"].loc[len(funds["mrtn_hmx"])] = row

            elif row["Fundo"] == "maratona":
                # copiar para o que representa o total
                funds["maratona"].loc[len(funds["maratona"])] = row
                funds["mrtn_hmx"].loc[len(funds["mrtn_hmx"])] = row
                # verificar se precisa copiar para o parcial(ex-vc)
                if (row["Grupo"] in check_partial) and (row["Luxor_Classification"] in ["stocks"]):
                    funds["maratona_acoes"].loc[len(funds["maratona_acoes"])] = row


            elif row["Fundo"] == "lipizzaner":
                # copiar para o que representa o total
                funds["lipizzaner"].loc[len(funds["lipizzaner"])] = row
                row_edel_lipi = row.copy()
                row_edel_lipi["Mkt_Value"] = row_edel_lipi["Mkt_Value"] * self.query_mngr.get_eduardo_lipi_particip(self.today)
                funds["edel_lipi"].loc[len(funds["edel_lipi"])] = row_edel_lipi
                if (row["Grupo"] in check_partial) : #and (row["Luxor_Classification"] in ["stocks"]):
                    funds["lipizzaner_acoes"].loc[len(funds["lipizzaner_acoes"])] = row
                    funds["edel_lipi_acoes"].loc[len(funds["edel_lipi_acoes"])] = row_edel_lipi

                if row["Grupo"] in check_partial_eqt: 
                    # Inserimos no all equities total
                    funds["all_eqt"].loc[len(funds["all_eqt"])] = row
                # verificamos se eh fia antes de inserir no acoes
                if (row["Grupo"] in check_partial_eqt_acoes) and (row["Luxor_Classification"] in ["stocks"]):
                    funds["all_eqt_acoes"].loc[len(funds["all_eqt_acoes"])] = row

            elif row["Fundo"] == "mangalarga fic fia":
                # copiar para o que representa o total
                funds["mangalarga_fic_fia"].loc[len(funds["mangalarga_fic_fia"])] = row
                #if row["Grupo"] in check_partial:
                #    funds["mangalarga_master_acoes"].loc[len(funds["mangalarga_master_acoes"])] = row
                #if row["Grupo"] in check_partial_eqt: 
                    # Inserimos no all equities total
                #    funds["all_eqt"].loc[len(funds["all_eqt"])] = row
                # verificamos se eh fia antes de inserir no acoes
                #if row["Grupo"] in check_partial_eqt_acoes:
                #    funds["all_eqt_acoes"].loc[len(funds["all_eqt_acoes"])] = row

        return funds


    def get_pls(self, funds):
        """
        Recebe como input um dicionario de dataframes de fundos
        Soma a coluna Mkt_Value de cada um e retorna um dicionário
        de pls, usando mesma chave
        """
        pls = {}

        for key, fund_df in funds.items():
            pl = fund_df["Mkt_Value"].sum()
            pls[key] = pl

        return pls


    def calculate_percentages(self, funds, pls):
        """Calcula o percentual de cada ativo no fundo."""

        for fund_key, fund_df in funds.items():
            # Repete para todos os fundos
            percents = []
            percents_abs = []

            try:
                for idx, row in fund_df.iterrows():
                    pct = row["Mkt_Value"]/pls[fund_key]
                    percents.append(pct)
                    percents_abs.append(abs(pct))

            except ZeroDivisionError:
                logger.error("Em 'calculate_percentage', divisao por pl 0")
            fund_df["%_pl"] = percents
            fund_df["%_pl_abs"] = percents_abs

        return funds


    def get_non_groupable_vcs(self, funds, metric=0.01):
        """
        Gera dicionario de vcs nao agrupaveis.
        As chaves sao os VCs e os valores uma lista com os fundos
        onde nao sera agrupado
        Será agrupável se for menor que o % informado por 'metric'
        """
        non_groupable = {
            f_name:[] for f_name in self.fund_names["vc_funds_all"]
        }

        for fund_name, fund_df in funds.items():
            if fund_name not in self.fund_names["vc_funds"]: continue

            for idx, row in fund_df.iterrows():
                if row["Grupo"] == "vc" and row["Ticker"] not in non_groupable[fund_name]:

                    if row["%_pl_abs"] >= metric:
                        non_groupable[fund_name].append(row["Ticker"])

        for f_name in self.fund_names["luxor_ptf"]:
            if f_name != "fund_a":
                non_groupable[f_name] = non_groupable["fund_a"][:]

        # fund_b + lipi recebe o mapa do fund_b (excecao)
        non_groupable["edel_lipi"] = non_groupable["fund_b"][:]
        non_groupable["mrtn_hmx"] = non_groupable["hmx"][:]


        return non_groupable


    def get_non_groupable_iliquids(self, funds, metric=0.01):
        """
        Gera dicionario de iliquids nao agrupaveis.
        Os valores sao os VCs/PEs numa lista e as chaves os nomes dos fundos
        onde nao sera agrupado
        Será agrupável se for menor que o % informado por 'metric'
        """
        non_groupable = {
            f_name:[] for f_name in self.fund_names["iliquids_funds"]
        }

        for fund_name, fund_df in funds.items():
            if fund_name not in self.fund_names["iliquids_funds"]: continue

            for idx, row in fund_df.iterrows():
                if (row["Grupo"] == "vc" or row["Grupo"] == "private equity") \
                        and row["Ticker"] not in non_groupable[fund_name]:
                    if row["%_pl_abs"] >= metric:
                        non_groupable[fund_name].append(row["Ticker"])


        # fund_b + lipi recebe o mapa do fund_b (excecao)
        non_groupable["edel_lipi"] = non_groupable["fund_b"][:]
        non_groupable["mrtn_hmx"] = non_groupable["hmx"][:]

        return non_groupable


    def get_non_groupable_iliquids_managers(self, funds, metric=0.01):
        """
        Gera dicionario de iliquids nao agrupaveis.
        Os valores sao os tickers VCs/PEs numa lista e as chaves os nomes dos fundos
        onde nao sera agrupado
        Será agrupável se for menor que o % informado por 'metric'
        """
        non_groupable = {
            f_name:[] for f_name in self.fund_names["iliquids_funds"]
        }

        for fund_name, fund_df in funds.items():
            if fund_name not in self.fund_names["iliquids_funds"]: continue

            # na coluna Manager, vamos substituir os valores nan pelo valor da coluna Ticker
            fund_df["Manager"] = np.where((fund_df["Manager"].isnull()) | (fund_df["Manager"] == 'nan'),
                                          fund_df["Ticker"], fund_df["Manager"])
            grouped_by_manager = fund_df[["Manager", "%_pl_abs"]].groupby("Manager").sum().reset_index()
            managers_not_to_group = grouped_by_manager.loc[grouped_by_manager["%_pl_abs"] >= metric, "Manager"]

            tickers_not_to_group = fund_df.query("Manager in @managers_not_to_group and \
                                                 (Grupo == 'vc' or Grupo == 'private equity')")["Ticker"]
            for ticker in tickers_not_to_group:
                non_groupable[fund_name].append(ticker)

        # fund_b + lipi recebe o mapa do fund_b (excecao)
        #non_groupable["edel_lipi"] = non_groupable["fund_b"][:]
        #non_groupable["mrtn_hmx"] = non_groupable["hmx"][:]

        return non_groupable


    def group_vcs(self, funds, non_groupable):
        """Altera a coluna 'Nomes' deixando diferente apenas o nome dos VCs
            que nao serao agrupados e com mesmo nome os que serao."""

        for fund_name, fund_df in funds.items():
            if fund_name not in self.fund_names["vc_funds_all"]: continue
            non_groupable_vcs = non_groupable[fund_name]

            for idx, fund_row in fund_df.iterrows():
                if fund_row["Grupo"] == "vc":

                    if fund_row["Ticker"] in non_groupable_vcs:
                        funds[fund_name].loc[idx, "Nome"] = self.query_mngr.get_asset_name(fund_row["Ticker"].lower())
                        funds[fund_name].loc[idx, "Asset"] = fund_row["Ticker"]
        return funds


    def group_iliquids(self, funds, non_groupable):
        """Altera a coluna 'Nomes' deixando diferente apenas o nome dos Iliquids
            que nao serao agrupados e com mesmo nome os que serao."""

        for fund_name, fund_df in funds.items():
            if fund_name not in self.fund_names["iliquids_funds"]: continue
            non_groupable_vcs = non_groupable[fund_name]

            for idx, fund_row in fund_df.iterrows():
                if fund_row["Grupo"] == "vc" or fund_row["Grupo"] == "private equity" or fund_row["Asset"] == 'tarpon':
                    if fund_row["Ticker"] in non_groupable_vcs:
                        # Tanto o nome quanto asset passarao a ser o Manager
                        # Quando o Manager for diferente da chave, vamos priorizar mostrar ele no nome
                        if fund_row["Ticker"] != fund_row["Manager"]:
                            funds[fund_name].loc[idx, "Nome"] = fund_row["Manager"].title()
                        else:
                            # Vamos pegar o nome cadastrado na tabela ativos
                            funds[fund_name].loc[idx, "Nome"] = self.query_mngr.get_asset_name(fund_row["Ticker"].lower())
                        #funds[fund_name].loc[idx, "Asset"] = fund_row["Ticker"]
                        funds[fund_name].loc[idx, "Asset"] = fund_row["Manager"]

                    else:
                        # Vamos trocar o Asset e o Nome para iliquids bz ou iliquids us 
                        location = fund_row["Currency Exposure"]
                        funds[fund_name].loc[idx, "Asset"] = "iliquids " + location
                        funds[fund_name].loc[idx, "Nome"] = "Iliquids " + location.upper()

        return funds


    def sum_rows_if(self, fund_df, grupo = [], tipo = [], ticker = [], asset = [],
                        row_to_sum = "%_pl", modifier="", name_1="Grupo", name_2="Tipo", 
                        name_3="Ticker", name_4="Asset"):
        """ Soma os % dos ativos em fund_df.
        No comportamento padrão, irá excluir da soma aqueles que estiverem informados em
        `grupo`, `tipo`, `ticker` ou `asset`.
        Esse comportamento pode ser alterado pelo modificador
        modificador: 
            `reverse` - Passa a somar somente os ativos definidos em grupo, tipo e ticker
            `grupo & ! tipo` - Somar apenas se estiver em grupo e nao estiver em tipo
            `if_negative` - soma somente valores negativos presentes na lista `grupo`
        """
        summation = 0
        if modifier == "":
            # por padrao, soma tudo menos o que estiver nas listas
            # precisa satisfazer todas as listas no mesmo row
            for idx, row in fund_df.iterrows():
                if (row[name_1] not in grupo) and (row[name_2] not in tipo) and (row[name_3] not in ticker) and (row[name_4] not in asset):
                    summation += row[row_to_sum]

        elif modifier == "reverse":
            # nessa variante, vai somar apenas se satisfizer as condicoes das listas
            for idx, row in fund_df.iterrows():
                if (len(grupo)== 0 or row[name_1] in grupo) and (len(tipo) == 0  or row[name_2] in tipo) and (len(ticker) == 0 or row[name_3] in ticker) and (len(asset) == 0 or row[name_4] in asset):
                    summation += row[row_to_sum]

        elif modifier == "grupo & !tipo":
            # nessa variante, vai somar apenas se estiver em grupo e nao estiver em tipo
            for idx, row in fund_df.iterrows():
                if (len(grupo) > 0 and row[name_1] in grupo) and (len(tipo) > 0  and row[name_2] not in tipo):
                    summation += row[row_to_sum]
        elif modifier == "if_negative":
            # Soma todos os valores negativos
            for idx, row in fund_df.iterrows():
                if row["%_pl"] < 0:
                    if name_1 == "Grupo":
                        if row[name_1] in grupo:
                            summation += row[row_to_sum]
                    elif name_1 == "Ticker":
                        if row[name_1] in ticker:
                            summation += row[row_to_sum]
        else:
            logger.error("Erro: Modificador não identificado.")


        return summation


    def value_at(self, fund_df, comp_col, comp_value, value_col, suppress_warnings=True, divide_by=1):

        try:
            comp_value = comp_value.lower()
            val = fund_df.loc[ fund_df[comp_col] == comp_value, value_col].iloc[0]          
            return val/divide_by

        except IndexError:
            if not suppress_warnings:
                fundo = fund_df.at[0,"Fundo"]
                logger.error(f"Não encontrado '{comp_value}' no {fundo}")
            return 0.0


    def transform_and_sum(self, fund_df, grupo, tipo = "", col1="Quantidade", col2="Price", operation="*", size=1):
        proc_df = fund_df.loc[ fund_df["Grupo"] == grupo ]
        result = 0.0
        for idx, row in proc_df.iterrows():
            row = row.fillna(0)
            if operation == "*":
                result += row[col1] * row[col2] * size

        return result


    def get_ndf_exposure(self, fund_df):

        ndfs = fund_df.query("Tipo == 'ndf usdbrl'")[["Quantidade", "Price"]]
        if len(ndfs) == 0: return 0
        ndfs["Exp"] = ndfs["Quantidade"] * ndfs["Price"]
        return -(ndfs["Exp"].sum())


    def compute_risk_metrics(self, funds):
        # Inicializar base com colunas:
        #    Fundo, Metrica, Valor
        # As metricas normalmente consistem em somar rows especificos
        # e dividir pelo pl.
        # Possivel talvez usar uma funcao generica que permite definir
        # alguns rows especificos e listar ao que ele deve se igualar

        metrics_names = []
        get_names = True
        risk_df = pd.DataFrame({})

        # Para drawdown global, vamos salvar alguns dados
        short_tot_glob = 0
        margin_tot_glob = 0

        assets = self.query_mngr.get_table("assets")

        for fund_name, fund_df in funds.items():

            if fund_name == "mangalarga_fic_fia":
                # Para o manga fic fia vamos copiar as metricas do manga master                 
                continue

            fund_metrics = []

            #Portfolio Long/PL
            grupo = ["short"]
            metric_val = self.sum_rows_if(fund_df, grupo)
            if get_names: metrics_names.append("Portfolio Long/PL")
            fund_metrics.append(metric_val)

            #Gross Exposure
            grupo = ["swap", "loan", "caixa", "caixa_us", "termo", "short", "taxas e custos", "ntnb"]
            metric_val = self.sum_rows_if(fund_df, grupo)
            if get_names: metrics_names.append("Gross Exposure")
            fund_metrics.append(metric_val)

            #Net Long
            # grupos que nao deve somar:
            grupo = ["caixa", "caixa_us", "swap", "termo", "loan", "taxas e custos", "ntnb"] # quando tiver ouro, tb nao pode impactar o net long.
            metric_val = self.sum_rows_if(fund_df, grupo)
            if get_names: metrics_names.append("Net Long")
            fund_metrics.append(metric_val)

            #Gross Eqt. Exp.
            grupo = ["caixa", "caixa_us", "swap", "termo", "loan", "rf_privada", "fundos", "short", "taxas e custos", "ntnb"]
            metric_val = self.sum_rows_if(fund_df, grupo)
            if get_names: metrics_names.append("Gross Equity Exp.")
            fund_metrics.append(metric_val)

            #Net Equity Exp.
            grupo = ["caixa", "caixa_us", "swap", "termo", "loan", "rf_privada", "fundos", "taxas e custos", "ntnb"]
            metric_val = self.sum_rows_if(fund_df, grupo)
            if get_names: metrics_names.append("Net Equity Exp.")
            fund_metrics.append(metric_val)

            #Net Public Eqt. Exp.
            grupo = ["caixa", "caixa_us", "swap", "termo", "loan", "rf_privada", "fundos", "vc", "taxas e custos", "ntnb"]
            metric_val = self.sum_rows_if(fund_df, grupo)
            if get_names: metrics_names.append("Net Public Eqt. Exp.")
            fund_metrics.append(metric_val)

            #% public Eqt.
            metric_val = self.sum_rows_if(fund_df, ["fundos_fia", "fundo_vc"], modifier="reverse") # fundo_vc era referente ao 3G. Venture capital nao entra
            metric_val += self.sum_rows_if(fund_df, ["ações"], ["spac", "spac_w"], modifier="grupo & !tipo")
            if get_names: metrics_names.append("% Public Eqt.")
            fund_metrics.append(metric_val)

            #% acoes.
            metric_val = self.sum_rows_if(fund_df, ["ações"], modifier="reverse") 
            if get_names: metrics_names.append("% Ações")
            fund_metrics.append(metric_val)

            #% fias.
            metric_val = self.sum_rows_if(fund_df, ["fundos_fia"], modifier="reverse") # fundo_vc era referente ao 3G. Venture capital nao entra
            if get_names: metrics_names.append("% FIAs")
            fund_metrics.append(metric_val)

            #% termos
            grupo = ["termo"]
            metric_val = self.sum_rows_if(fund_df, grupo, modifier="reverse", row_to_sum="%_pl_abs")
            if get_names: metrics_names.append("% Termos")
            fund_metrics.append(metric_val)

            #% VC
            grupo = ["vc"]
            metric_val = self.sum_rows_if(fund_df, grupo, modifier="reverse")
            if get_names: metrics_names.append("% VCs")
            fund_metrics.append(metric_val)

            #% Private Equity
            grupo = ["private equity"]
            metric_val = self.sum_rows_if(fund_df, grupo, modifier="reverse")
            if get_names: metrics_names.append("% PE")
            fund_metrics.append(metric_val)


             #% Hedge Funds
            grupo = ["fundos"]
            metric_val = self.sum_rows_if(fund_df, grupo, modifier="reverse")
            if get_names: metrics_names.append("% Hedge Funds")
            fund_metrics.append(metric_val)

            #% P&L Swap + termos
            grupo = ["swap", "termo", "caixa", "caixa_us", "loan", "swap_eurusd", "fut_dol"]
            metric_val = self.sum_rows_if(fund_df, grupo=grupo, modifier="if_negative")
            if get_names: metrics_names.append("% Passivos")
            fund_metrics.append(metric_val)

            #% P&L Swap
            grupo = ["swap_eurusd"]
            metric_val = self.sum_rows_if(fund_df, grupo, modifier="reverse")
            if get_names: metrics_names.append("% P&L Swap EURUSD")
            fund_metrics.append(metric_val)

            #% Renda fixa privada (fidcs)
            grupo = ["rf_privada"]
            metric_val = self.sum_rows_if(fund_df, grupo, modifier="reverse")
            if get_names: metrics_names.append("% Fixed Income")
            fund_metrics.append(metric_val)

            #% SPACs
            tipo = ["spac", "spac_w"]
            metric_val = self.sum_rows_if(fund_df, tipo=tipo, modifier="reverse")
            if get_names: metrics_names.append("% SPACs")
            fund_metrics.append(metric_val)

            #% BDRs
            tipo = ["ações_bdr"]
            metric_val = self.sum_rows_if(fund_df, tipo=tipo, modifier="reverse")
            if get_names: metrics_names.append("% BDRs")
            fund_metrics.append(metric_val)

            #Offshore
            metric_val_offshore = self.sum_rows_if(fund_df, ["us"], name_1="Currency Exposure", modifier="reverse")
            if get_names: metrics_names.append("Offshore")
            fund_metrics.append(metric_val_offshore)

            #Onshore
            metric_val_onshore = self.sum_rows_if(fund_df, ["us"], name_1="Currency Exposure")
            if get_names: metrics_names.append("Onshore")
            fund_metrics.append(metric_val_onshore)

            #Hedge Dol

            fut_dol = self.transform_and_sum(fund_df, grupo="fut_dol", size=-50)
            swap_exp = self.value_at(fund_df, "Tipo", "swap_exp", "Quantidade")
            ndf_exp = self.get_ndf_exposure(fund_df)
            if fund_name =='edel_lipi':
                ndf_exp = ndf_exp * self.query_mngr.get_eduardo_lipi_particip(self.today)

            #if fund_name in ["fund_b", "hmx", "fund_a", "edel_lipi"]:
                # variar exposicao offshore 
            #    exps = {"fund_b" : 1600000, "hmx" : 1780000, "fund_a" : 0, "edel_lipi" : 1600000*self.USD_BRL}
            #    swap_exp += exps[fund_name]
            metric_val_hedge = (fut_dol + swap_exp + ndf_exp)/self.pls[fund_name]


            if get_names: metrics_names.append("Hedge Dol")
            fund_metrics.append(metric_val_hedge)

            #Exp USD
            metric_val = metric_val_offshore - metric_val_hedge
            if get_names: metrics_names.append("Exp. USD")  
            fund_metrics.append(metric_val)

            #Sup. Aju. Dol
            metric_val = self.value_at(fund_df, "Asset", "Sup. Aju. DOL", "Quantidade")
            if get_names: metrics_names.append("Sup. Aju. DOL") #TODO precisa do caixa segregado
            fund_metrics.append(metric_val)

            #Enquadramento: offshore + acoes e fias onshore
            metric_val = self.sum_rows_if(fund_df, tipo = ["ações", "ações_bdr", "ações_us", "caixa_us",
                                                           "fundo_fia", "omega", "spac", "vc bz", "vc us", 
                                                           "term debt", "unidas", "equity_fund", "etf"],
                                                            modifier="reverse")
            if fund_name == "lipizzaner":
                metric_val = ((self.pls["fund_a"] * self.USD_BRL)/self.pls["lipizzaner"]) + self.sum_rows_if(fund_df, tipo = ["ações", "ações_bdr", "fundo_fia", "omega","term debt"], modifier="reverse")

            if get_names: metrics_names.append("Enquadramento")
            fund_metrics.append(metric_val)

            #S KHC: somar %_pl ações khc vendido
            metric_val_s_khc = self.sum_rows_if(fund_df, ["ações"], ["kraft heinz"], name_2="Asset", modifier="reverse")
            if get_names: metrics_names.append("S KHC")
            fund_metrics.append(metric_val_s_khc)

            #Caixa Bloqueado
            metric_cx_bloq = abs(metric_val_s_khc) + self.sum_rows_if(fund_df, ["short"], row_to_sum = "%_pl_abs", modifier="reverse")
            if get_names: metrics_names.append("Caixa Bloqueado")
            fund_metrics.append(metric_cx_bloq)

            #Caixa Livre
            metric_val = -metric_cx_bloq + self.sum_rows_if(fund_df, ["caixa", "caixa_us"], row_to_sum = "%_pl", modifier="reverse")
            if get_names: metrics_names.append("Caixa Livre")
            fund_metrics.append(metric_val)

            #% loan
            metric_val = self.sum_rows_if(fund_df, ["loan"], row_to_sum = "%_pl_abs", modifier="reverse")
            if get_names: metrics_names.append("% Loan")
            fund_metrics.append(metric_val)

            #Alavancagem Caixa
            metric_val = self.sum_rows_if(fund_df, ["caixa", "caixa_us", "loan"], row_to_sum = "%_pl", modifier="reverse")
            metric_val = 0 if metric_val > 0 else abs(metric_val)
            if get_names: metrics_names.append("Alavancagem Caixa")
            fund_metrics.append(metric_val)

            #JPM Money Market
            metric_val_mar_co = self.value_at(fund_df, "Asset", "JP Money Market", "Quantidade")
            if get_names: metrics_names.append("JP Money Market")
            fund_metrics.append(metric_val_mar_co)

            #Margin Cost
            metric_val_mar_co = self.value_at(fund_df, "Asset", "Margin Cost (SOFR +85bps)", "Quantidade")
            if get_names: metrics_names.append("Margin Cost (SOFR +85bps)")
            fund_metrics.append(metric_val_mar_co)

            #Retorno Short
            metric_val_ret_sh = self.value_at(fund_df, "Asset", "Retorno Short", "Quantidade")
            if get_names: metrics_names.append("Retorno Short")
            fund_metrics.append(metric_val_ret_sh)

            #Carry Loan: return_short - margin_cost
            paid_in_khc_dividends = 0.0414 * 0.7 - 0.0414
            metric_val = metric_val_ret_sh - metric_val_mar_co + paid_in_khc_dividends
            if get_names: metrics_names.append("Custo Short KHC")
            fund_metrics.append(metric_val)

            #Drawdown - limite margem
            short_tot = self.sum_rows_if(fund_df, ["caixa_us", "loan"], modifier="reverse", row_to_sum="Mkt_Value")

            # % Capital Commited (USD)
            checklist = self.fund_names["simulated"] + self.fund_names["onshore"] #+ ["lipi"] #, "manga"]
            multiplier = 1 if fund_name not in checklist else self.USD_BRL

            comm_usd = self.value_at(fund_df, "Ticker", "usd commited capital", "Quantidade", divide_by=self.pls[fund_name]) * multiplier
            comm_brl = self.value_at(fund_df, "Ticker", "brl commited capital", "Quantidade", divide_by=self.pls[fund_name])

            metric_val = comm_usd + comm_brl
            if get_names: metrics_names.append("% Uncalled Capital")
            fund_metrics.append(metric_val)


            # TODO APAGAR DEPOIS DE EFETIVADO #LOAN #EMPRESTIMO #EDUARDO
            if fund_name == "fund_b":
                short_tot -= 1200000    # Emprestimo do Edu Garantido pela Edelweiss (conta como garantia)
                #short_tot -= 2600000    # 2.6mm esprestimo Zaratustra garantido pela Edelweiss


            short_khc = self.value_at(fund_df, "Ticker", "khc us equity", "Mkt_Value")
            short_tot += short_khc

            margin_tot = self.sum_rows_if(fund_df, ["ações"], modifier="reverse", row_to_sum="Mkt_Value") - short_khc

            metric_val = (-(short_tot)/0.5)/margin_tot - 1
            if get_names: metrics_names.append("Max Drawdown - ML")
            fund_metrics.append(metric_val)


            # Drawdown global - limite margem
            other_fund = "fund_b" if fund_name == "fund_a" else "fund_a"

            short_tot_glob = self.sum_rows_if(funds[other_fund], ["caixa_us", "loan"], modifier="reverse", row_to_sum="Mkt_Value")
            if other_fund == "fund_b":
                short_tot_glob -= 1200000   # Emprestimo do Edu Garantido pela Edelweiss (conta como garantia)
                #short_tot_glob -= 2600000    # 2.6mm esprestimo Zaratustra garantido pela Edelweiss

            other_short_khc = self.value_at(funds[other_fund], "Ticker", "khc us equity", "Mkt_Value")
            short_tot_glob += other_short_khc + short_tot
            margin_tot_glob = self.sum_rows_if(funds[other_fund], ["ações"], modifier="reverse", row_to_sum="Mkt_Value") - other_short_khc
            margin_tot_glob += margin_tot
            metric_val = (-(short_tot_glob)/0.5)/margin_tot_glob - 1
            if get_names: metrics_names.append("Max Drawdown Global - ML")
            fund_metrics.append(metric_val)

            # % Luxor
            stocks_tickers = list(assets.query("Luxor_Classification.isin(['stocks'])")["Ticker"])
            metric_val = self.sum_rows_if(fund_df,
                ticker=stocks_tickers, row_to_sum = "%_pl", modifier="reverse")
            if get_names: metrics_names.append("% Luxor")
            fund_metrics.append(metric_val)

            # % ETF S&P
            metric_val = self.sum_rows_if(fund_df, asset=['etf s&p'], row_to_sum = "%_pl", modifier="reverse")
            if get_names: metrics_names.append("% ETF S&P")
            fund_metrics.append(metric_val)

            # % IP Atlas
            metric_val = self.sum_rows_if(fund_df, asset=['ip atlas'], row_to_sum = "%_pl", modifier="reverse")
            if get_names: metrics_names.append("% IP")
            fund_metrics.append(metric_val)

            # % SPX Hawker
            metric_val = self.sum_rows_if(fund_df, asset=['spx hawker', 'spx eagle'], row_to_sum = "%_pl", modifier="reverse")
            if get_names: metrics_names.append("% SPX Hawker")
            fund_metrics.append(metric_val)

            # % TCI
            metric_val = self.sum_rows_if(fund_df, asset=['tci'], row_to_sum = "%_pl", modifier="reverse")
            if get_names: metrics_names.append("% TCI")
            fund_metrics.append(metric_val)

            # % Cash (classification = Fixed Income e % PL > 0)
            cash_assets = list(assets.query("Luxor_Classification.isin(['fixed income'])")["Ticker"]) + ['ibit us equity']
            metric_val = self.sum_rows_if(fund_df, ticker=cash_assets, row_to_sum = "%_pl", modifier="reverse")
            metric_val_debt = self.sum_rows_if(fund_df, ticker=cash_assets, row_to_sum = "%_pl", modifier="if_negative", name_1="Ticker")
            metric_val = metric_val - metric_val_debt # Devolvendo o percentual que foi subtraido.
            if get_names: metrics_names.append("% Cash")
            fund_metrics.append(metric_val)

            # % Iliquids
            metric_val = self.sum_rows_if(fund_df,
                grupo=['vc', 'private equity'], row_to_sum = "%_pl", modifier="reverse")
            if get_names: metrics_names.append("% Iliquids")
            fund_metrics.append(metric_val)

            # % BR Equity Funds
            metric_val = self.sum_rows_if(fund_df, grupo=['fundos_fia'], row_to_sum = "%_pl", modifier="reverse")
            if get_names: metrics_names.append("% BR Equity Funds")
            fund_metrics.append(metric_val)

            # % Equities
            equities = list(assets.query("Luxor_Classification.isin(['equity funds', 'stocks', 'vc', 'private equity'])")["Ticker"])
            metric_val = self.sum_rows_if(fund_df,
                ticker=equities, row_to_sum = "%_pl", modifier="reverse")
            if get_names: metrics_names.append("% Equity")
            fund_metrics.append(metric_val)

            # % Debt
            debt_metric = self.sum_rows_if(fund_df,
                grupo=['caixa', 'caixa_us', 'loan', 'termo', 'taxas e custos'], row_to_sum = "%_pl", modifier="if_negative")

            # % Non Equities
            equities = list(assets.query("Luxor_Classification.isin(['equity funds', 'stocks', 'vc', 'private equity'])")["Ticker"])
            metric_val = self.sum_rows_if(fund_df,
                ticker=equities, row_to_sum = "%_pl",)
            metric_val = metric_val - debt_metric
            if get_names: metrics_names.append("% Non Equity")
            fund_metrics.append(metric_val)
            # Adicionando % Debt depois, para aparecer por ultimo na ordem
            if get_names: metrics_names.append("% Debt")
            fund_metrics.append(debt_metric)

            # % Leverage com relacao as acoes
            if fund_name in self.fund_names['partial']:
                reference_portfolio_name = self.partial_to_complete_name_map[fund_name]
                reference_portfolio = funds[reference_portfolio_name]
            else:
                reference_portfolio = fund_df

            total_debt = self.sum_rows_if(reference_portfolio, 
                                            grupo=['caixa', 'caixa_us', 'loan', 'termo', 'taxas e custos'],
                                            row_to_sum="Mkt_Value", modifier='reverse')
            total_equity = self.sum_rows_if(fund_df, grupo=['ações'], row_to_sum="Mkt_Value", modifier='reverse') 
            metric_val = total_debt/total_equity
            if metric_val > 0:
                metric_val = 0
            metric_val = abs(metric_val)
            #print(f"Fund: {fund_name}, debt:{total_debt}, equity:{total_equity}, leverage:{metric_val}")
            if get_names: metrics_names.append("% Leverage vs stocks")
            fund_metrics.append(metric_val)


            if get_names:
                # preenche df com nomes das metricas e ordem de exibicao
                risk_df["Métrica"] = metrics_names
                order = [i for i in range(len(metrics_names))]
                risk_df["Ordem"] = order
                get_names = False

            # adiciona metricas do fundo
            risk_df[fund_name] = fund_metrics
            if fund_name == "lipizzaner":
                risk_df["mangalarga_fic_fia"] = fund_metrics  

        return risk_df


    def compute_positions_variation(self):
        """
            Calcula a variacao de posicoes de cada fundo num periodo determidado e gera um output
        """
        fund_names = ["Lipizzaner", "Fund A", "Fund B", "Mangalarga FIC FIA"]

        # Definindo data mais atual(hoje), numero de dias que vamos voltar e data anterior
        recent_date = self.query_mngr.get_bday_offset(self.today,offset=0)

        days_offset = dt.timedelta(days=7)
        if dt.date.today() == dt.date(2025,2,10):
            #Ajuste da data, para pegar variacao completa do periodo de aporte no IP Atlas
            days_offset = dt.timedelta(days=11) 

        previous_date = self.query_mngr.get_bday_offset(self.today-days_offset,offset=0)
        print(f"delta_positions_date: {previous_date}")

        assets = self.query_mngr.get_table("assets")

        variations = []

        for f_name in fund_names:

            spx_hawker_keys = ["spx hawker_spx hawker cl aset18", "spx hawker_spx seg hawker jan22", "spx hawker_spx hawker cl amar22", "spx hawker_spx seg hawker feb22"]

            diff = self.query_mngr.get_position_variation(f_name.lower(), recent_date, previous_date).query("Key not in @spx_hawker_keys")

            closed = list(diff.loc[diff["Closed"], "Key"])
            bought = list(diff.loc[diff["Variation"] > 0.01, "Key"])
            sold = list(diff.loc[((diff["Variation"] < -0.01) & (~diff["Closed"])), "Key"])

            f_variations = [f_name]
            for k in closed:
                if "term debt" not in k.lower():
                    row =  assets[assets["Key"] == k]
                    name = row["Name"].squeeze()
                    modifier = "Zeragem "
                    f_variations.append(modifier+name)

            for k in bought:
                if "term debt" not in k.lower():
                    row =  assets[assets["Key"] == k]
                    name = row["Name"].squeeze()
                    modifier = "B "
                    if row["Group"].squeeze() == "vc":
                        modifier = ""
                    f_variations.append(modifier+name)

            for k in sold:
                if "term debt" not in k.lower():
                    row =  assets[assets["Key"] == k]
                    name = row["Name"].squeeze()
                    modifier = "S "

                    f_variations.append(modifier+name)

            variations.append(f_variations.copy())

        variations = pd.DataFrame(variations).transpose()
        variations = variations.rename(columns=variations.iloc[0]).drop(variations.index[0]).fillna("-")

        return variations


    def compute_metrics_variation(self):

        fund_names = ["Lipizzaner", "Fund A", "Fund B", "Mangalarga FIC FIA", "Maratona"]
        variations = None
        # Definindo data mais atual(hoje), numero de dias que vamos voltar e data anterior
        recent_date = self.query_mngr.get_bday_offset(self.today,offset=0)
        days_offset = dt.timedelta(days=7)

        days_offset = dt.timedelta(days=7)
        if dt.date.today() == dt.date(2025,2,10):
            #Ajuste da data, para pegar variacao completa do periodo de aporte no IP Atlas
            days_offset = dt.timedelta(days=11) 

        previous_date = self.query_mngr.get_bday_offset(self.today-days_offset,offset=0)

        print(f"delta_metrics_date: {previous_date}")

        for f_name in fund_names:

            metrics_variations = self.query_mngr.get_risk_metric_variation(f_name.lower(), recent_date, previous_date)
            metrics_variations["Fund"] = f_name.lower()
            if variations is None:
                variations = metrics_variations.copy()
            else:
                variations = pd.concat([variations, metrics_variations])

        return variations


    def process_assets_concat(self, funds):
        """Agrupa as linhas que representam o mesmo 'Asset'
           acumulando os percentuais e editando o nome mostrado.

           Atenção: método modifica diretamente self.funds
        """
        def __concat_asset(gpd_rows, fund_name):

            if len(gpd_rows) <= 1:
                return gpd_rows

            # Obtendo do gpd_rows, o valor do asset referente ao grupo

            rows_to_delete = gpd_rows.index.tolist()

            # separa um row para ser alterado
            row = gpd_rows.iloc[0].copy()

            qtd, mkt_val, pct_pl = 0,0,0
            pct_grouped = ""

            # somando valores que precisam ficar nos dados agrupados
            for idx, row in gpd_rows.iterrows():
                qtd += row["Quantidade"]
                mkt_val += row["Mkt_Value"]
                pct_pl += row["%_pl"]
                gpd_name = " ".join(row["Ticker"].split(" ")[:3]) if row["Grupo"] != "vc" and row["Grupo"] != "private equity" and row["Tipo"] != 'fidc trybe' else row["Ticker"]

                #gpd_name = row["Ticker"].split(" ")[0] if row["Grupo"] != "vc" and row["Tipo"] != 'fidc trybe' else row["Ticker"]

                pct_grouped += gpd_name.upper() +" \t"+ "{:.2f}".format(row["%_pl"]*100) + "%\n"

            if row["Grupo"] == "vc" or row["Grupo"] == 'private equity':
                if row["Nome"].lower() in ['iliquids bz', 'iliquids us']:
                    asset = row["Nome"].lower() 
                    row["Asset"] = asset

            row["Nome"] = row["Nome"].replace("Fund Ii", "Fund II")

            row["Quantidade"] = qtd
            row["Mkt_Value"] = mkt_val
            row["%_pl"] = pct_pl
            if qtd != 0:
                row["Price"] = mkt_val/qtd
            row["%_pl_abs"] = abs(pct_pl)
            row["%_agrupados"] = pct_grouped.strip("\n")

            # precisamos descobrir qual categoria de ativos estamos agrupando
            # para saber como personalizar o nome mostrado 
            # podemos obter uma lista dos tipos presentes:
            asset_types = gpd_rows["Tipo"].tolist()

            try: 
                # Descomentar caso voltemos a ter spacs 
                #if ("spac" in asset_types) or ("spac_w" in asset_types):
                #    # mapear alteracao para spacs
                #    extra_pct = gpd_rows.loc[ gpd_rows["Tipo"] == "spac_w", "%_pl"].iloc[0]
                #    extra_pct = "{:.1f}".format(extra_pct*100)
                #    row["Nome"] = row["Nome"] + "|Warrant " + extra_pct + "%"

                if "omega" in asset_types:
                    # mapear alteracao para omega|poraque
                    pct_omge = gpd_rows.loc[ gpd_rows["Tipo"] == "ações", "%_pl"].iloc[0]
                    pct_omge = "{:.1f}".format(pct_omge*100)
                    row["Nome"] += "|OMGE3 " + pct_omge + "%"

                #elif "unidas" in asset_types:
                #    # mapear alteracao para localiza|unidas
                #    pct_lcam = gpd_rows.loc[ gpd_rows["Tipo"] == "unidas", "%_pl"].iloc[0]
                #    pct_lcam = "{:.1f}".format(pct_lcam*100)
                #    row["Nome"] += "|LCAM3 " + pct_lcam + "%"


                if ("ações_bdr" in asset_types) and (fund_name in self.fund_names["trading"]):
                    # personalizar com qtd BDRs
                    pct_bdr = gpd_rows.loc[ gpd_rows["Tipo"] == "ações_bdr", "%_pl"].iloc[0]
                    pct_bdr = "{:.1f}".format(pct_bdr*100)
                    row["Nome"] += "|BDR " + pct_bdr + "%"

            except Exception:
                logger.error("Falha ao tentar formatar nome dos ativos agrupados.")

                sys.exit()   

            for idx in rows_to_delete:
                self.funds[fund_name].drop(idx, inplace=True)


            self.funds[fund_name].loc[rows_to_delete[0]] = row

        # Repetimos o mesmo processo para todas as carteiras

        for fund_name, fund_df in funds.items():


            #fund_df["Asset"] = fund_df["Asset"].apply(lambda x: x.replace("fidc trybe ii", "fidc trybe").replace("fidc trybe i", "fidc trybe"))
            #fund_df["Nome"] = fund_df["Nome"].apply(lambda x: x.replace("FIDC Trybe II", "FIDC Trybe").replace("FIDC Trybe I", "FIDC Trybe"))

            # primeiro colocamos uma nova coluna para manter % dos rows agrupados
            fund_df["%_agrupados"] = None
            fund_df.reset_index(drop=True).groupby("Asset", as_index=False).apply(
                        lambda gpd_rows: __concat_asset(gpd_rows, fund_name),
                        include_groups=False
                        )


    #def split_assets_rule(self, funds):
#
    #    aportes_resgates = {
    #        "mangalarga master" : {"spx hawker" : 3300000.00 * self.USD_BRL, "verde" : 7600000},
    #        "lipi" : {"verde" : 1625000, "capstone" : 1075000}
    #    }
    #    
    #    for fund_name in funds:
#
    #        data = self.funds[fund_name].copy()
    #        data["%_pl_mov"] = 0
    #        data["%_pl_abs_mov"] = 0
    #        rows_to_append = []
    #        for idx, row in data.iterrows():
    #            split_row = False
    #            mkt_val_var = 0
    #            if row["Fundo"] in aportes_resgates:
    #                if row["Asset"] in aportes_resgates[row["Fundo"]]:
    #                    split_row = True
    #                    mkt_val_var = aportes_resgates[row["Fundo"]][row["Asset"]]
    #                elif row["Ticker"] in aportes_resgates[row["Fundo"]]:
    #                    split_row = True
    #                    mkt_val_var = aportes_resgates[row["Fundo"]][row["Ticker"]]
    #            if split_row:
    #                
    #                new_row = row.copy()
    #                row["Mkt_Value"] -= mkt_val_var
    #                row["%_pl"] -= mkt_val_var/self.pls[fund_name]
    #                row["%_pl_abs"] -= abs(mkt_val_var/self.pls[fund_name])
    #                
    #                new_row["Mkt_Value"] = mkt_val_var
    #                new_row["Cor"] = self.colors["verde_escuro"]
    #                new_row["%_pl_mov"] = mkt_val_var/self.pls[fund_name]
    #                new_row["%_pl_abs_mov"] = abs(mkt_val_var/self.pls[fund_name])
    #                #new_row["Asset"] = row["Asset"]+"_mov"
    #                rows_to_append.append(new_row)
    #                    
    #            
    #        for row in rows_to_append:
    #            data.loc[len(data)] = row
#
    #        self.funds[fund_name] = data
#

    def define_assets_order(self, funds):

        for fund_name, fund_df in funds.items():
            order = []

            for idx, fund_row in fund_df.iterrows():
                order_key = fund_row["Grupo"]
                if fund_row["Tipo"] in ["spac", "spac_w"]:
                    order_key = fund_row["Tipo"] 

                mod = self.order_modifiers[order_key]
                mod = mod - fund_row["Mkt_Value"]
                order.append(mod)

            funds[fund_name]["Ordem"] = order

        return self.funds


    def __create_exec_info(self):
        """Coloca Data e Hora da execução num DataFrame."""
        #date_time = dt.datetime.now()

        #date_time = date_time.strftime("%d/%m/%Y %H:%M:%S").split()
        date = dt.datetime.today().strftime("%d/%m/%Y")
        time = self.query_mngr.get_px_update_time().strftime("%H:%M:%S")


        #Desconto unidas TODO: TEMPORARIO, REMOVER DEPOIS
        #Portfolio Long/PL
        #px_localiza = self.asset_prices.loc["rent3 bz equity"].iloc[0]
        #unidas_pos_deal = px_localiza*0.4468

        #px_unidas = self.asset_prices.loc["lcam3 bz equity"].iloc[0]
        #unidas_ex_div = px_unidas - 0.835414
        #desconto_unidas = unidas_pos_deal/unidas_ex_div -1
        #print(f"desconto lcam/rent: {desconto_unidas}" )

        #df = pd.DataFrame({
        #    "Data" : [date_time[0]],
        #    "Hora" : [date_time[1]],
        #    "Desc_LCAM3" : 1,
        #})
        df = pd.DataFrame({
            "Data" : [date],
            "Hora" : [time],
            "Desc_LCAM3" : 1,
        })
        return df

    def __create_lipi_investors_table(self):

        lipi_investors = pd.DataFrame({}, columns=["Investor", "%_invested"])

        manga_fic_invested = self.query_mngr.calculate_fund_particip("mangalarga fic fia", "lipizzaner", date=self.today)
        manga_ii_fic_invested = self.query_mngr.calculate_fund_particip("mangalarga ii fic fia", "lipizzaner", date=self.today)
        eduardo_invested = self.query_mngr.get_eduardo_lipi_particip(date=self.today) #1 - manga_fic_invested - manga_ii_fic_invested

        lipi_investors.loc[len(lipi_investors)] = {"Investor" : "% Manga FIC", "%_invested" : manga_fic_invested}
        lipi_investors.loc[len(lipi_investors)] = {"Investor" : "% Manga II FIC", "%_invested" : manga_ii_fic_invested}
        lipi_investors.loc[len(lipi_investors)] = {"Investor" : '% Eduardo', "%_invested" : eduardo_invested}

        return lipi_investors


    def calculate_day_attr(self, funds):

        funds_updated = {}
        def __calculate_attr(fund_name, prev_ptf, cur_ptf_row):

            if cur_ptf_row["Quantidade"] == 0: return 0

            if cur_ptf_row["Tipo"] in ["caixa", "caixa_us"] and fund_name != "lipizzaner_acoes":
                return 0

            asset_key = cur_ptf_row["Key"]
            prev_asset_row = prev_ptf.query("Key == @asset_key")
            if len(prev_asset_row) != 1:
                return 0

            # obtendo peso do ativo na carteira anterior
            prev_weight = prev_asset_row["%_pl"].squeeze()
            variation = 0
            if cur_ptf_row["Tipo"] not in ["caixa", "caixa_us"]:

                # Determinando preco atual, a partir do valor de mercado e quantidades
                cur_mkt_val = cur_ptf_row["Mkt_Value"]
                cur_amnt = cur_ptf_row["Quantidade"]
                cur_price = cur_mkt_val/cur_amnt

                prev_mkt_val = prev_asset_row["Mkt_Value"].squeeze()
                prev_amnt = prev_asset_row["Quantidade"].squeeze()
                prev_price = prev_mkt_val/prev_amnt
                if prev_price == 0: return 0

                variation = (cur_price/prev_price) -1
            elif cur_ptf_row["Tipo"] == "caixa":
                variation = cur_ptf_row["Selic"]/prev_asset_row["Selic"].squeeze()-1

            elif cur_ptf_row["Tipo"] == "caixa_us":
                variation = cur_ptf_row["USDBRL"]/prev_asset_row["USDBRL"].squeeze()-1

            return prev_weight * variation

        #Obtendo portfolios do dia anterior
        prev_ptfs_path = Path("carteiras_luxor_historico")/"bases_completas"
        filename = "base_portfolios_" + str(self.yesterday) + ".xlsx"
        prev_ptfs_file_path = prev_ptfs_path/filename
        prev_ptfs = pd.read_excel(prev_ptfs_file_path, sheet_name=None)

        #print(prev_ptfs_file_path)
        # Iterando pelos portfolios atualizados de hoje
        for fund_name, fund_df in funds.items():

            fund_df["Key"] = fund_df["Asset"] + fund_df["Ticker"]
            #try:
            prev_ptf = prev_ptfs[fund_name]

            fund_df["USDBRL"] = self.USD_BRL
            fund_df["Date"] = self.today
            fund_df["Selic"] = self.query_mngr.get_price("bzacselc index")
            fund_df["Key"] = fund_df["Asset"] + "_" + fund_df["Ticker"]


            fund_df["%_attr"] = fund_df.apply(lambda row: __calculate_attr(fund_name, prev_ptf, row), axis=1)
            #except:
                #print(f"Nao foi encotrado portfolio anterior para a carteira '{fund_name}'")
                #pass

            funds_updated[fund_name] = fund_df.copy()

        return funds_updated


    def set_date_and_usdbrl(self, funds):

        funds_updated = {}
        for fund_name, fund_df in funds.items():
            fund_df["Date"] = self.today
            fund_df['USDBRL'] = self.USD_BRL
            funds_updated[fund_name] = fund_df.copy()


        return funds_updated


    def save_portfolio_full_database(self, funds):
        filename = "base_portfolios.xlsx"
        path = Path("bases_output")/filename


        writer = pd.ExcelWriter(path, engine='xlsxwriter')

        for fund_name, fund_df in funds.items():
            fund_df.to_excel(writer, index=False, sheet_name=fund_name)

        writer.close()

        if (dt.datetime.now().hour >= 17)  or (self.today<dt.date.today()) : #or (dt.datetime.now().hour < 9):
            # entao vamos salvar uma base extra para controle de exposicao
            date = self.today
            #if dt.datetime.now().hour < 9:
            #    # salvamos antes da abertura o fechamento de ontem -> Nao, pois esta deixando inconsistencias nas metricas.
            #    date -= dt.timedelta(days=1)

            filename = "base_portfolios" + "_" + str(date)+".xlsx"
            path_bases_completas = Path("carteiras_luxor_historico")/"bases_completas"/filename
            filename = "Gerencial Luxor.xlsx"
            path_reconciliacao = Path().absolute().parents[3]/"BackOffice"/"01 - Carteiras"/"Conciliação Diária Bancos"/filename

            for path in [path_bases_completas, path_reconciliacao]:
                writer = pd.ExcelWriter(path, engine='xlsxwriter')
                for fund_name, fund_df in funds.items():
                    fund_df.to_excel(writer, index=False, sheet_name=fund_name)

                committed_capital_data = pd.read_excel(self.input_bases_dir/self.input_base_file, sheet_name="Committed Capital")
                committed_capital_data.to_excel(writer, index=False, sheet_name="committed_capital")

                writer.close()


    def save_portfolio_risk_metrics(self):

        # Salvamos sempre ~~apenas com o mercado fechado~~
        #if dt.datetime.now().hour >= 17 or dt.datetime.now().hour < 9:
        df = self.risk_df.copy()

        today = self.today
        # if dt.datetime.now().hour < 9: 
        #     # Entao estamos rodando a carteira de ontem!! -> Nao. Vamos rodar a de ontem somente quando solicitado explicitamente!
        #     # Pegamos entao o dia util anterior
        #     today = today - dt.timedelta(days = max(1, (today.weekday() + 6) % 7 -3) )

        df["Date"] = today
        filename = "hist_risk_metrics.xlsx"
        filepath = Path("carteiras_luxor_historico")/"metricas_risco"/filename

        # Vamos ler o conteudo do arquivo primeiro
        data = pd.read_excel(filepath, engine="openpyxl").dropna(how="any")
        data["Date"] = data["Date"].dt.date

        # Vamos descartar tudo que estiver no dia de hoje ou depois
        data = data.loc[data["Date"] < today]

        # Vamos juntar as bases. Em caso de n.a., repetimos o valor da metrica do dia anterior
        data = pd.concat([data, df]).ffill()#fillna(method="ffill")
        print(data)
        # Sobrescrevendo arquivo com dados atualizados
        data.to_excel(filepath, index=False)


    def save_portfolio(self, funds):

        filename = "base_carteira_online_v12.xlsx"
        if self.is_develop_branch:
            # Alteramos arquivo de saida se for branch develop
            filename = "base_carteira_online_v12_develop.xlsx"

        paths = [
            os.path.join(self.onedrive_path, filename),
            os.path.join(os.getcwd(), "bases_output", filename)
        ]
        for path in paths:       
            writer = pd.ExcelWriter(path, engine='xlsxwriter')

            for fund_name, fund_df in funds.items():

                f = fund_df.copy()
                #f = f.drop("Luxor_Classification", axis=1)
                f.to_excel(writer, index=False, sheet_name=fund_name)

            writer.close()


    def run(self):

        self.query_mngr.update()
        self.build()

__create_exec_info()

Coloca Data e Hora da execução num DataFrame.

Source code in carteira_online/production/portfolio_builder.py

def __create_exec_info(self):
    """Coloca Data e Hora da execução num DataFrame."""
    #date_time = dt.datetime.now()

    #date_time = date_time.strftime("%d/%m/%Y %H:%M:%S").split()
    date = dt.datetime.today().strftime("%d/%m/%Y")
    time = self.query_mngr.get_px_update_time().strftime("%H:%M:%S")


    #Desconto unidas TODO: TEMPORARIO, REMOVER DEPOIS
    #Portfolio Long/PL
    #px_localiza = self.asset_prices.loc["rent3 bz equity"].iloc[0]
    #unidas_pos_deal = px_localiza*0.4468

    #px_unidas = self.asset_prices.loc["lcam3 bz equity"].iloc[0]
    #unidas_ex_div = px_unidas - 0.835414
    #desconto_unidas = unidas_pos_deal/unidas_ex_div -1
    #print(f"desconto lcam/rent: {desconto_unidas}" )

    #df = pd.DataFrame({
    #    "Data" : [date_time[0]],
    #    "Hora" : [date_time[1]],
    #    "Desc_LCAM3" : 1,
    #})
    df = pd.DataFrame({
        "Data" : [date],
        "Hora" : [time],
        "Desc_LCAM3" : 1,
    })
    return df

__load_funds_base(filename)

Carrega base de dados com as carteiras dos fundos. Concatena todas numa tabela só. Args: file_name (str): caminho para arquivo .xlsx

Returns:

Type	Description
	Dataframe de pandas

Source code in carteira_online/production/portfolio_builder.py

def __load_funds_base(self, filename):
    """
        Carrega base de dados com as carteiras dos fundos.
        Concatena todas numa tabela só.
        Args:
            file_name (str): caminho para arquivo .xlsx

        Returns:
            Dataframe de pandas
    """
    try:
        data = pd.read_excel(self.input_bases_dir/filename, sheet_name=["Lipizzaner", "Fund A", "Fund B", "HMX", "Mangalarga FIC", "Maratona"])        

        # tratando dados:
        for k, v in data.items():
            data[k] = v[ v.columns[:4] ].dropna(how="any")
            data[k] = data[k].loc[ ((data[k]["Quantidade"] != 0) | (data[k]["Ticker"] == "Caixa (a receber)")), :]

        # caixa a receber
        f_data = data["Fund A"]
        idx_mod = f_data.loc[((f_data["Asset"] == "Caixa (a receber)") & (f_data["Ticker"] == "Caixa (a receber)"))].index[0]

        f_data.at[idx_mod, "Quantidade"] = 0/self.USD_BRL
        data["Fund A"] = f_data.copy()

        f_data = data["Lipizzaner"]
        idx_mod = f_data.loc[((f_data["Asset"] == "Caixa (a receber)") & (f_data["Ticker"] == "Caixa (a receber)"))].index[0]
        f_data.at[idx_mod, "Quantidade"] = 0/self.USD_BRL # global vai multiplicar pelo mesmo dolar depois e netar
        data["Lipizzaner"] = f_data.copy()

        # Seguiremos com os dados concatenados para facilitar por enquanto
        data = pd.concat(data.values(), ignore_index=True)

        # Antes de converter para lower case, copiar coluna Assets
        assets_copy = data["Asset"]
        # converte todo o texto para lower case
        data = data.apply(lambda row: row.astype(str).str.lower())

        # remove espacos em branco do inicio e do fim de cada entrada
        data = data.apply(lambda row: row.str.strip())

        # coluna quantidade precisa ser reconvertida para numerico
        try:
            data["Quantidade"] = pd.to_numeric(data["Quantidade"]).round(8)
        except:
            logger.error("Voce errou, humano.")
            logger.error("Tem texto onde era pra ter quantidade.")
            logger.error(data["Quantidade"])
            data.to_excel("error.xlsx")
            sys.exit()

        # Inserindo coluna com nomes personalizavel
        data["Nome"] = assets_copy
        data["Nome"] = data["Nome"].apply(lambda x: x.replace(" |", "|").replace("| ", "|"))

        cols = ["Nome"] + [col for col in data.columns if col != "Nome"]

        data = data[cols]

        return data

    except FileNotFoundError:
        logger.error(f"Arquivo {filename} não encontrado em {self.input_bases_dir}")
        logger.error("Finalizando...")
        sys.exit()

__update_colors(data)

Atualiza a cor com base em algum criterio. Por enquanto, apenas coloca como vermelho se o market value for negativo.

Source code in carteira_online/production/portfolio_builder.py

def __update_colors(self, data):
    """Atualiza a cor com base em algum criterio.
    Por enquanto, apenas coloca como vermelho se o
    market value for negativo.
    """
    for idx, row in data.iterrows():
        if row["Mkt_Value"] < 0:
            data.loc[idx, "Cor"] = self.colors["vermelho"]
        else:
            data.loc[idx, "Cor"] = self.color_map[row["Grupo"]]

    return data

calculate_MktVal(data)

Calcula o valor de mercado de cada ativo em cada fundo base

Source code in carteira_online/production/portfolio_builder.py

def calculate_MktVal(self, data):
    """
    Calcula o valor de mercado de cada ativo em cada fundo base
    """
    def __get_MktVal(row):
        #if row["Grupo"] == "fut_dol":
        #    return 0

        if row["Tipo"] == 'ndf usdbrl':
            # Vai ser calculado pela variacao em relacao ao preco medio *  quantidade
            avg_price = self.query_mngr.get_avg_price(row["Fundo"], row["Asset"]+"_"+row["Ticker"], self.today)
            if avg_price < 0.1 and row["Fundo"] == 'lipizzaner':
                # ativo esta pelo fund a
                avg_price = self.query_mngr.get_avg_price('fund a', row["Asset"]+"_"+row["Ticker"], self.today)

            ndf_price = self.query_mngr.get_price(row["Ticker"])

            if row['Fundo'] in self.fund_names["onshore"]:
                return row["Quantidade"] * (ndf_price-avg_price) # Resultado em BRL
            return row["Quantidade"] * ((ndf_price/avg_price)-1) # Resultado em USD

        if row["Fundo"] in self.fund_names["onshore"]:
            # Nos onshore precisamos corrigir alguns precos pelo dolar
            if row["Location"] == "us" and row["Ticker"] not in ["spx seg hawker jun23", "SPX SEG HAWKER SEP23".lower()]:
                return row["Quantidade"] * row["Price"] * self.USD_BRL

        return row["Quantidade"] * row["Price"]

    data["Mkt_Value"] = data.apply(lambda row: __get_MktVal(row), axis=1)
    return data

calculate_percentages(funds, pls)

Calcula o percentual de cada ativo no fundo.

Source code in carteira_online/production/portfolio_builder.py

def calculate_percentages(self, funds, pls):
    """Calcula o percentual de cada ativo no fundo."""

    for fund_key, fund_df in funds.items():
        # Repete para todos os fundos
        percents = []
        percents_abs = []

        try:
            for idx, row in fund_df.iterrows():
                pct = row["Mkt_Value"]/pls[fund_key]
                percents.append(pct)
                percents_abs.append(abs(pct))

        except ZeroDivisionError:
            logger.error("Em 'calculate_percentage', divisao por pl 0")
        fund_df["%_pl"] = percents
        fund_df["%_pl_abs"] = percents_abs

    return funds

compute_positions_variation()

Calcula a variacao de posicoes de cada fundo num periodo determidado e gera um output

Source code in carteira_online/production/portfolio_builder.py

def compute_positions_variation(self):
    """
        Calcula a variacao de posicoes de cada fundo num periodo determidado e gera um output
    """
    fund_names = ["Lipizzaner", "Fund A", "Fund B", "Mangalarga FIC FIA"]

    # Definindo data mais atual(hoje), numero de dias que vamos voltar e data anterior
    recent_date = self.query_mngr.get_bday_offset(self.today,offset=0)

    days_offset = dt.timedelta(days=7)
    if dt.date.today() == dt.date(2025,2,10):
        #Ajuste da data, para pegar variacao completa do periodo de aporte no IP Atlas
        days_offset = dt.timedelta(days=11) 

    previous_date = self.query_mngr.get_bday_offset(self.today-days_offset,offset=0)
    print(f"delta_positions_date: {previous_date}")

    assets = self.query_mngr.get_table("assets")

    variations = []

    for f_name in fund_names:

        spx_hawker_keys = ["spx hawker_spx hawker cl aset18", "spx hawker_spx seg hawker jan22", "spx hawker_spx hawker cl amar22", "spx hawker_spx seg hawker feb22"]

        diff = self.query_mngr.get_position_variation(f_name.lower(), recent_date, previous_date).query("Key not in @spx_hawker_keys")

        closed = list(diff.loc[diff["Closed"], "Key"])
        bought = list(diff.loc[diff["Variation"] > 0.01, "Key"])
        sold = list(diff.loc[((diff["Variation"] < -0.01) & (~diff["Closed"])), "Key"])

        f_variations = [f_name]
        for k in closed:
            if "term debt" not in k.lower():
                row =  assets[assets["Key"] == k]
                name = row["Name"].squeeze()
                modifier = "Zeragem "
                f_variations.append(modifier+name)

        for k in bought:
            if "term debt" not in k.lower():
                row =  assets[assets["Key"] == k]
                name = row["Name"].squeeze()
                modifier = "B "
                if row["Group"].squeeze() == "vc":
                    modifier = ""
                f_variations.append(modifier+name)

        for k in sold:
            if "term debt" not in k.lower():
                row =  assets[assets["Key"] == k]
                name = row["Name"].squeeze()
                modifier = "S "

                f_variations.append(modifier+name)

        variations.append(f_variations.copy())

    variations = pd.DataFrame(variations).transpose()
    variations = variations.rename(columns=variations.iloc[0]).drop(variations.index[0]).fillna("-")

    return variations

get_non_groupable_iliquids(funds, metric=0.01)

Gera dicionario de iliquids nao agrupaveis. Os valores sao os VCs/PEs numa lista e as chaves os nomes dos fundos onde nao sera agrupado Será agrupável se for menor que o % informado por 'metric'

Source code in carteira_online/production/portfolio_builder.py

def get_non_groupable_iliquids(self, funds, metric=0.01):
    """
    Gera dicionario de iliquids nao agrupaveis.
    Os valores sao os VCs/PEs numa lista e as chaves os nomes dos fundos
    onde nao sera agrupado
    Será agrupável se for menor que o % informado por 'metric'
    """
    non_groupable = {
        f_name:[] for f_name in self.fund_names["iliquids_funds"]
    }

    for fund_name, fund_df in funds.items():
        if fund_name not in self.fund_names["iliquids_funds"]: continue

        for idx, row in fund_df.iterrows():
            if (row["Grupo"] == "vc" or row["Grupo"] == "private equity") \
                    and row["Ticker"] not in non_groupable[fund_name]:
                if row["%_pl_abs"] >= metric:
                    non_groupable[fund_name].append(row["Ticker"])


    # fund_b + lipi recebe o mapa do fund_b (excecao)
    non_groupable["edel_lipi"] = non_groupable["fund_b"][:]
    non_groupable["mrtn_hmx"] = non_groupable["hmx"][:]

    return non_groupable

get_non_groupable_iliquids_managers(funds, metric=0.01)

Gera dicionario de iliquids nao agrupaveis. Os valores sao os tickers VCs/PEs numa lista e as chaves os nomes dos fundos onde nao sera agrupado Será agrupável se for menor que o % informado por 'metric'

Source code in carteira_online/production/portfolio_builder.py

def get_non_groupable_iliquids_managers(self, funds, metric=0.01):
    """
    Gera dicionario de iliquids nao agrupaveis.
    Os valores sao os tickers VCs/PEs numa lista e as chaves os nomes dos fundos
    onde nao sera agrupado
    Será agrupável se for menor que o % informado por 'metric'
    """
    non_groupable = {
        f_name:[] for f_name in self.fund_names["iliquids_funds"]
    }

    for fund_name, fund_df in funds.items():
        if fund_name not in self.fund_names["iliquids_funds"]: continue

        # na coluna Manager, vamos substituir os valores nan pelo valor da coluna Ticker
        fund_df["Manager"] = np.where((fund_df["Manager"].isnull()) | (fund_df["Manager"] == 'nan'),
                                      fund_df["Ticker"], fund_df["Manager"])
        grouped_by_manager = fund_df[["Manager", "%_pl_abs"]].groupby("Manager").sum().reset_index()
        managers_not_to_group = grouped_by_manager.loc[grouped_by_manager["%_pl_abs"] >= metric, "Manager"]

        tickers_not_to_group = fund_df.query("Manager in @managers_not_to_group and \
                                             (Grupo == 'vc' or Grupo == 'private equity')")["Ticker"]
        for ticker in tickers_not_to_group:
            non_groupable[fund_name].append(ticker)

    # fund_b + lipi recebe o mapa do fund_b (excecao)
    #non_groupable["edel_lipi"] = non_groupable["fund_b"][:]
    #non_groupable["mrtn_hmx"] = non_groupable["hmx"][:]

    return non_groupable

get_non_groupable_vcs(funds, metric=0.01)

Gera dicionario de vcs nao agrupaveis. As chaves sao os VCs e os valores uma lista com os fundos onde nao sera agrupado Será agrupável se for menor que o % informado por 'metric'

Source code in carteira_online/production/portfolio_builder.py

def get_non_groupable_vcs(self, funds, metric=0.01):
    """
    Gera dicionario de vcs nao agrupaveis.
    As chaves sao os VCs e os valores uma lista com os fundos
    onde nao sera agrupado
    Será agrupável se for menor que o % informado por 'metric'
    """
    non_groupable = {
        f_name:[] for f_name in self.fund_names["vc_funds_all"]
    }

    for fund_name, fund_df in funds.items():
        if fund_name not in self.fund_names["vc_funds"]: continue

        for idx, row in fund_df.iterrows():
            if row["Grupo"] == "vc" and row["Ticker"] not in non_groupable[fund_name]:

                if row["%_pl_abs"] >= metric:
                    non_groupable[fund_name].append(row["Ticker"])

    for f_name in self.fund_names["luxor_ptf"]:
        if f_name != "fund_a":
            non_groupable[f_name] = non_groupable["fund_a"][:]

    # fund_b + lipi recebe o mapa do fund_b (excecao)
    non_groupable["edel_lipi"] = non_groupable["fund_b"][:]
    non_groupable["mrtn_hmx"] = non_groupable["hmx"][:]


    return non_groupable

get_pls(funds)

Recebe como input um dicionario de dataframes de fundos Soma a coluna Mkt_Value de cada um e retorna um dicionário de pls, usando mesma chave

Source code in carteira_online/production/portfolio_builder.py

def get_pls(self, funds):
    """
    Recebe como input um dicionario de dataframes de fundos
    Soma a coluna Mkt_Value de cada um e retorna um dicionário
    de pls, usando mesma chave
    """
    pls = {}

    for key, fund_df in funds.items():
        pl = fund_df["Mkt_Value"].sum()
        pls[key] = pl

    return pls

group_iliquids(funds, non_groupable)

Altera a coluna 'Nomes' deixando diferente apenas o nome dos Iliquids que nao serao agrupados e com mesmo nome os que serao.

Source code in carteira_online/production/portfolio_builder.py

def group_iliquids(self, funds, non_groupable):
    """Altera a coluna 'Nomes' deixando diferente apenas o nome dos Iliquids
        que nao serao agrupados e com mesmo nome os que serao."""

    for fund_name, fund_df in funds.items():
        if fund_name not in self.fund_names["iliquids_funds"]: continue
        non_groupable_vcs = non_groupable[fund_name]

        for idx, fund_row in fund_df.iterrows():
            if fund_row["Grupo"] == "vc" or fund_row["Grupo"] == "private equity" or fund_row["Asset"] == 'tarpon':
                if fund_row["Ticker"] in non_groupable_vcs:
                    # Tanto o nome quanto asset passarao a ser o Manager
                    # Quando o Manager for diferente da chave, vamos priorizar mostrar ele no nome
                    if fund_row["Ticker"] != fund_row["Manager"]:
                        funds[fund_name].loc[idx, "Nome"] = fund_row["Manager"].title()
                    else:
                        # Vamos pegar o nome cadastrado na tabela ativos
                        funds[fund_name].loc[idx, "Nome"] = self.query_mngr.get_asset_name(fund_row["Ticker"].lower())
                    #funds[fund_name].loc[idx, "Asset"] = fund_row["Ticker"]
                    funds[fund_name].loc[idx, "Asset"] = fund_row["Manager"]

                else:
                    # Vamos trocar o Asset e o Nome para iliquids bz ou iliquids us 
                    location = fund_row["Currency Exposure"]
                    funds[fund_name].loc[idx, "Asset"] = "iliquids " + location
                    funds[fund_name].loc[idx, "Nome"] = "Iliquids " + location.upper()

    return funds

group_vcs(funds, non_groupable)

Altera a coluna 'Nomes' deixando diferente apenas o nome dos VCs que nao serao agrupados e com mesmo nome os que serao.

Source code in carteira_online/production/portfolio_builder.py

def group_vcs(self, funds, non_groupable):
    """Altera a coluna 'Nomes' deixando diferente apenas o nome dos VCs
        que nao serao agrupados e com mesmo nome os que serao."""

    for fund_name, fund_df in funds.items():
        if fund_name not in self.fund_names["vc_funds_all"]: continue
        non_groupable_vcs = non_groupable[fund_name]

        for idx, fund_row in fund_df.iterrows():
            if fund_row["Grupo"] == "vc":

                if fund_row["Ticker"] in non_groupable_vcs:
                    funds[fund_name].loc[idx, "Nome"] = self.query_mngr.get_asset_name(fund_row["Ticker"].lower())
                    funds[fund_name].loc[idx, "Asset"] = fund_row["Ticker"]
    return funds

merge_data(assets_data, funds_data)

Realiza junção interna sobre as colunas 'Asset' e 'Ticker' Args: assets_data (Pandas Dataframe): Base com dados dos ativos funds_data (Pandas Dataframe): Base com dados dos fundos

Returns:

Type	Description
	Pandas Dataframe: Base com os dados unificados

Source code in carteira_online/production/portfolio_builder.py

def merge_data(self, assets_data, funds_data):
    """Realiza junção interna sobre as colunas 'Asset' e 'Ticker'
    Args:
        assets_data (Pandas Dataframe): Base com dados dos ativos
        funds_data (Pandas Dataframe): Base com dados dos fundos

    Returns:
        Pandas Dataframe: Base com os dados unificados
    """
    data = pd.merge(funds_data, assets_data,
                     how="inner", on=["Asset","Ticker"])
    return data

populate_prices_BBG(data)

Popula a coluna 'Prices' com o preco atual de cada ativo. Se nao for aplicavel, preenche com valor 1.

Parameters:

Name	Type	Description	Default
data		Dataframe de pandas com dados da carteira e ativos concatenados	required

Returns: Dataframe de pandas com coluna de preços preenchida

Source code in carteira_online/production/portfolio_builder.py

def populate_prices_BBG(self, data):
    """Popula a coluna 'Prices' com o preco atual de cada ativo.
        Se nao for aplicavel, preenche com valor 1.

    Args:
        data: Dataframe de pandas com dados da carteira e ativos
              concatenados
    Returns:
        Dataframe de pandas com coluna de preços preenchida
    """

    def __get_price(row):
        # Função auxiliar para preencher condicionalmente
        swaps_zerados = True
        # se nao tem ticker bbg, preco valera 1
        if row["Ticker_BBG"] == "nan": 
            # TODO calculos das metricas internamente
            if row["Grupo"] == "metricas":
                return 0

            if row["Grupo"] == "swap":
                if row["Fundo"].lower() == "maratona":
                    return 1
                # Se for swap, retorna o p&l
                if row["Tipo"] == "swap_p&l":
                    if "liq" in row["Ticker"]:
                        return 1
                    if swaps_zerados : return 0
                    #else:
                        # 
                    return self.data_extractor.get_swap_pnl(row["Fundo"].title())

                elif row["Tipo"] == "swap_exp":
                    if swaps_zerados : return 0 # ALTERAR PARA PEGAR METRICA DE EXPOSICAO

                    return self.data_extractor.get_swap_exp(row["Fundo"].title())

            #ip_atlas= "Outrigger Fund Ltd - IP Atlas USD Equity Class - Subclass B".lower()
            #if row["Ticker"] == ip_atlas:
            #    return 1000

            if row["Grupo"] == 'termo':
                # Vamos pegar o preco medio da execucao, que eh o preco do termo fixo
                try:
                    df = self.query_mngr.get_table("last_positions_by_bank")
                    ticker = row["Ticker"].lower()

                    price = df.query("Ticker == @ticker").tail(1)["Avg_price"].squeeze()
                    return -price
                except:
                    logger.error(f"Erro ao buscar preco do termo {ticker}")
                    pass

            price = self.query_mngr.get_price(row["Ticker"], px_date=self.today)
            if price == 0 or price is None: #Nao encontrado
                price = 1

            #if row["Grupo"] == "termo":
            #    price = -price

            return price

        else:

            price = self.query_mngr.get_price(row["Ticker_BBG"])
            #if row["Ticker_BBG"] == 'lzrfy us equity':
            #    price = self.query_mngr.get_price("rent3 bz equity")
            #    price = price/self.query_mngr.get_price("usdbrl curncy")

            # Preco do contrato de dolar vai ser a variacao de um dia pro outro
            if row["Tipo"] in ["fut_dol", "fut_dol_min"]:
                px_today = self.query_mngr.get_price(row["Ticker_BBG"])
                prev_date = self.query_mngr.get_bday_offset(self.today, -1, location="bz")
                px_prev = self.query_mngr.get_price(row["Ticker_BBG"], px_date=prev_date)
                size = 50 if row["Tipo"] == "fut_dol" else 10

                price = (px_today - px_prev) * size

            # Se for bdr, precisaremos ajustar pelo peso
            if row["Tipo"] == "ações_bdr":
                bdr_ticker = row["Ticker"]
                peso = self.query_mngr.get_bdr_size(bdr_ticker)


                #if bdr_ticker == "amzo34 bz equity":
                #    print("-------> PESO DE AMZO34 ALTERADO NA MAO!!!!!! <-----------")
                #    peso = peso*20
                price = price * self.USD_BRL / peso

            # AJUSTES MANUAIS DE PRECO, FAZER AQUI!
            #if row["Ticker"] == "poraque fic fip" and price < 50000:
            #    print(">>>> PREÇO DE OMEGA AJUSTADO MANUALMENTE <<<<")
            #    
            #    price = 216526.697109

            return  price

    data["Price"] = data.apply(lambda row: __get_price(row), axis=1)

    return data

process_assets_concat(funds)

Agrupa as linhas que representam o mesmo 'Asset' acumulando os percentuais e editando o nome mostrado.

Atenção: método modifica diretamente self.funds

Source code in carteira_online/production/portfolio_builder.py

def process_assets_concat(self, funds):
    """Agrupa as linhas que representam o mesmo 'Asset'
       acumulando os percentuais e editando o nome mostrado.

       Atenção: método modifica diretamente self.funds
    """
    def __concat_asset(gpd_rows, fund_name):

        if len(gpd_rows) <= 1:
            return gpd_rows

        # Obtendo do gpd_rows, o valor do asset referente ao grupo

        rows_to_delete = gpd_rows.index.tolist()

        # separa um row para ser alterado
        row = gpd_rows.iloc[0].copy()

        qtd, mkt_val, pct_pl = 0,0,0
        pct_grouped = ""

        # somando valores que precisam ficar nos dados agrupados
        for idx, row in gpd_rows.iterrows():
            qtd += row["Quantidade"]
            mkt_val += row["Mkt_Value"]
            pct_pl += row["%_pl"]
            gpd_name = " ".join(row["Ticker"].split(" ")[:3]) if row["Grupo"] != "vc" and row["Grupo"] != "private equity" and row["Tipo"] != 'fidc trybe' else row["Ticker"]

            #gpd_name = row["Ticker"].split(" ")[0] if row["Grupo"] != "vc" and row["Tipo"] != 'fidc trybe' else row["Ticker"]

            pct_grouped += gpd_name.upper() +" \t"+ "{:.2f}".format(row["%_pl"]*100) + "%\n"

        if row["Grupo"] == "vc" or row["Grupo"] == 'private equity':
            if row["Nome"].lower() in ['iliquids bz', 'iliquids us']:
                asset = row["Nome"].lower() 
                row["Asset"] = asset

        row["Nome"] = row["Nome"].replace("Fund Ii", "Fund II")

        row["Quantidade"] = qtd
        row["Mkt_Value"] = mkt_val
        row["%_pl"] = pct_pl
        if qtd != 0:
            row["Price"] = mkt_val/qtd
        row["%_pl_abs"] = abs(pct_pl)
        row["%_agrupados"] = pct_grouped.strip("\n")

        # precisamos descobrir qual categoria de ativos estamos agrupando
        # para saber como personalizar o nome mostrado 
        # podemos obter uma lista dos tipos presentes:
        asset_types = gpd_rows["Tipo"].tolist()

        try: 
            # Descomentar caso voltemos a ter spacs 
            #if ("spac" in asset_types) or ("spac_w" in asset_types):
            #    # mapear alteracao para spacs
            #    extra_pct = gpd_rows.loc[ gpd_rows["Tipo"] == "spac_w", "%_pl"].iloc[0]
            #    extra_pct = "{:.1f}".format(extra_pct*100)
            #    row["Nome"] = row["Nome"] + "|Warrant " + extra_pct + "%"

            if "omega" in asset_types:
                # mapear alteracao para omega|poraque
                pct_omge = gpd_rows.loc[ gpd_rows["Tipo"] == "ações", "%_pl"].iloc[0]
                pct_omge = "{:.1f}".format(pct_omge*100)
                row["Nome"] += "|OMGE3 " + pct_omge + "%"

            #elif "unidas" in asset_types:
            #    # mapear alteracao para localiza|unidas
            #    pct_lcam = gpd_rows.loc[ gpd_rows["Tipo"] == "unidas", "%_pl"].iloc[0]
            #    pct_lcam = "{:.1f}".format(pct_lcam*100)
            #    row["Nome"] += "|LCAM3 " + pct_lcam + "%"


            if ("ações_bdr" in asset_types) and (fund_name in self.fund_names["trading"]):
                # personalizar com qtd BDRs
                pct_bdr = gpd_rows.loc[ gpd_rows["Tipo"] == "ações_bdr", "%_pl"].iloc[0]
                pct_bdr = "{:.1f}".format(pct_bdr*100)
                row["Nome"] += "|BDR " + pct_bdr + "%"

        except Exception:
            logger.error("Falha ao tentar formatar nome dos ativos agrupados.")

            sys.exit()   

        for idx in rows_to_delete:
            self.funds[fund_name].drop(idx, inplace=True)


        self.funds[fund_name].loc[rows_to_delete[0]] = row

    # Repetimos o mesmo processo para todas as carteiras

    for fund_name, fund_df in funds.items():


        #fund_df["Asset"] = fund_df["Asset"].apply(lambda x: x.replace("fidc trybe ii", "fidc trybe").replace("fidc trybe i", "fidc trybe"))
        #fund_df["Nome"] = fund_df["Nome"].apply(lambda x: x.replace("FIDC Trybe II", "FIDC Trybe").replace("FIDC Trybe I", "FIDC Trybe"))

        # primeiro colocamos uma nova coluna para manter % dos rows agrupados
        fund_df["%_agrupados"] = None
        fund_df.reset_index(drop=True).groupby("Asset", as_index=False).apply(
                    lambda gpd_rows: __concat_asset(gpd_rows, fund_name),
                    include_groups=False
                    )

sum_rows_if(fund_df, grupo=[], tipo=[], ticker=[], asset=[], row_to_sum='%_pl', modifier='', name_1='Grupo', name_2='Tipo', name_3='Ticker', name_4='Asset')

Soma os % dos ativos em fund_df. No comportamento padrão, irá excluir da soma aqueles que estiverem informados em grupo, tipo, ticker ou asset. Esse comportamento pode ser alterado pelo modificador modificador: reverse - Passa a somar somente os ativos definidos em grupo, tipo e ticker grupo & ! tipo - Somar apenas se estiver em grupo e nao estiver em tipo if_negative - soma somente valores negativos presentes na lista grupo

Source code in carteira_online/production/portfolio_builder.py

def sum_rows_if(self, fund_df, grupo = [], tipo = [], ticker = [], asset = [],
                    row_to_sum = "%_pl", modifier="", name_1="Grupo", name_2="Tipo", 
                    name_3="Ticker", name_4="Asset"):
    """ Soma os % dos ativos em fund_df.
    No comportamento padrão, irá excluir da soma aqueles que estiverem informados em
    `grupo`, `tipo`, `ticker` ou `asset`.
    Esse comportamento pode ser alterado pelo modificador
    modificador: 
        `reverse` - Passa a somar somente os ativos definidos em grupo, tipo e ticker
        `grupo & ! tipo` - Somar apenas se estiver em grupo e nao estiver em tipo
        `if_negative` - soma somente valores negativos presentes na lista `grupo`
    """
    summation = 0
    if modifier == "":
        # por padrao, soma tudo menos o que estiver nas listas
        # precisa satisfazer todas as listas no mesmo row
        for idx, row in fund_df.iterrows():
            if (row[name_1] not in grupo) and (row[name_2] not in tipo) and (row[name_3] not in ticker) and (row[name_4] not in asset):
                summation += row[row_to_sum]

    elif modifier == "reverse":
        # nessa variante, vai somar apenas se satisfizer as condicoes das listas
        for idx, row in fund_df.iterrows():
            if (len(grupo)== 0 or row[name_1] in grupo) and (len(tipo) == 0  or row[name_2] in tipo) and (len(ticker) == 0 or row[name_3] in ticker) and (len(asset) == 0 or row[name_4] in asset):
                summation += row[row_to_sum]

    elif modifier == "grupo & !tipo":
        # nessa variante, vai somar apenas se estiver em grupo e nao estiver em tipo
        for idx, row in fund_df.iterrows():
            if (len(grupo) > 0 and row[name_1] in grupo) and (len(tipo) > 0  and row[name_2] not in tipo):
                summation += row[row_to_sum]
    elif modifier == "if_negative":
        # Soma todos os valores negativos
        for idx, row in fund_df.iterrows():
            if row["%_pl"] < 0:
                if name_1 == "Grupo":
                    if row[name_1] in grupo:
                        summation += row[row_to_sum]
                elif name_1 == "Ticker":
                    if row[name_1] in ticker:
                        summation += row[row_to_sum]
    else:
        logger.error("Erro: Modificador não identificado.")


    return summation