Spaces:
Running
Running
| import pandas as pd | |
| import numpy as np | |
| import gradio as gr | |
| import os | |
| import io | |
| import tempfile | |
| import time | |
| import pytz | |
| from datetime import datetime | |
| # Path to the CSV file | |
| CSV_FILE_PATH = "./dados/input.csv" | |
| # --- Helper functions (create_8_band_inputs, create_2_band_inputs) remain the same --- | |
| def create_8_band_inputs(prefix, defaults_lim, defaults_aliq): | |
| inputs = [] | |
| labels_lim = [f"{prefix} Limite {i+1} (UFM)" for i in range(7)] | |
| labels_aliq = [f"{prefix} Alíquota {i+1} (ex: 0.004 para 0.4%)" for i in range(8)] | |
| with gr.Row(): | |
| inputs.append(gr.Number(label=labels_lim[0], value=defaults_lim[0], min_width=50)) | |
| inputs.append(gr.Number(label=labels_aliq[0], value=defaults_aliq[0], min_width=50)) | |
| with gr.Row(): | |
| inputs.append(gr.Number(label=labels_lim[1], value=defaults_lim[1], min_width=50)) | |
| inputs.append(gr.Number(label=labels_aliq[1], value=defaults_aliq[1], min_width=50)) | |
| with gr.Row(): | |
| inputs.append(gr.Number(label=labels_lim[2], value=defaults_lim[2], min_width=50)) | |
| inputs.append(gr.Number(label=labels_aliq[2], value=defaults_aliq[2], min_width=50)) | |
| with gr.Row(): | |
| inputs.append(gr.Number(label=labels_lim[3], value=defaults_lim[3], min_width=50)) | |
| inputs.append(gr.Number(label=labels_aliq[3], value=defaults_aliq[3], min_width=50)) | |
| with gr.Row(): | |
| inputs.append(gr.Number(label=labels_lim[4], value=defaults_lim[4], min_width=50)) | |
| inputs.append(gr.Number(label=labels_aliq[4], value=defaults_aliq[4], min_width=50)) | |
| with gr.Row(): | |
| inputs.append(gr.Number(label=labels_lim[5], value=defaults_lim[5], min_width=50)) | |
| inputs.append(gr.Number(label=labels_aliq[5], value=defaults_aliq[5], min_width=50)) | |
| with gr.Row(): | |
| inputs.append(gr.Number(label=labels_lim[6], value=defaults_lim[6], min_width=50)) | |
| inputs.append(gr.Number(label=labels_aliq[6], value=defaults_aliq[6], min_width=50)) | |
| with gr.Row(): | |
| inputs.append(gr.Number(label=labels_aliq[7], value=defaults_aliq[7], min_width=50)) # Only aliquot for the last band | |
| return inputs | |
| def create_2_band_inputs(prefix, default_lim, defaults_aliq): | |
| inputs = [] | |
| with gr.Row(): | |
| inputs.append(gr.Number(label=f"{prefix} Limite 1 (UFM)", value=default_lim, min_width=50)) | |
| inputs.append(gr.Number(label=f"{prefix} Alíquota 1 (ex: 0.0)", value=defaults_aliq[0], min_width=50)) | |
| with gr.Row(): | |
| inputs.append(gr.Number(label=f"{prefix} Alíquota 2 (ex: 0.03)", value=defaults_aliq[1], min_width=50)) | |
| return inputs | |
| # --- Function to create parameters sheet --- | |
| def create_parameters_sheet(valor_venal_choice, ufm_value, diferencia_estacionamentos_flag, diferencia_predios_flag, all_parameters): | |
| """Create a DataFrame with all parameters used in the calculation""" | |
| # Extract parameters from the list in the correct order | |
| params = all_parameters | |
| # Parameter mapping | |
| param_data = [] | |
| # General parameters | |
| param_data.append(['CONFIGURAÇÕES GERAIS', '', '']) | |
| param_data.append(['Valor Venal Utilizado', valor_venal_choice, '']) | |
| param_data.append(['Valor da UFM', ufm_value, '']) | |
| param_data.append(['Diferenciar Estacionamentos por Uso', 'Sim' if diferencia_estacionamentos_flag else 'Não', '']) | |
| param_data.append(['Diferenciar Prédios por Uso', 'Sim' if diferencia_predios_flag else 'Não', '']) | |
| param_data.append(['', '', '']) | |
| # Predial Geral (PG) - 15 parameters | |
| param_data.append(['PREDIAL GERAL (PG)', '', '']) | |
| pg_params = params[0:15] | |
| param_data.extend([ | |
| ['PG Limite 1 (UFM)', pg_params[0], ''], | |
| ['PG Alíquota 1', pg_params[1], f'{pg_params[1]*100:.3f}%' if pg_params[1] else ''], | |
| ['PG Limite 2 (UFM)', pg_params[2], ''], | |
| ['PG Alíquota 2', pg_params[3], f'{pg_params[3]*100:.3f}%' if pg_params[3] else ''], | |
| ['PG Limite 3 (UFM)', pg_params[4], ''], | |
| ['PG Alíquota 3', pg_params[5], f'{pg_params[5]*100:.3f}%' if pg_params[5] else ''], | |
| ['PG Limite 4 (UFM)', pg_params[6], ''], | |
| ['PG Alíquota 4', pg_params[7], f'{pg_params[7]*100:.3f}%' if pg_params[7] else ''], | |
| ['PG Limite 5 (UFM)', pg_params[8], ''], | |
| ['PG Alíquota 5', pg_params[9], f'{pg_params[9]*100:.3f}%' if pg_params[9] else ''], | |
| ['PG Limite 6 (UFM)', pg_params[10], ''], | |
| ['PG Alíquota 6', pg_params[11], f'{pg_params[11]*100:.3f}%' if pg_params[11] else ''], | |
| ['PG Limite 7 (UFM)', pg_params[12], ''], | |
| ['PG Alíquota 7', pg_params[13], f'{pg_params[13]*100:.3f}%' if pg_params[13] else ''], | |
| ['PG Alíquota 8', pg_params[14], f'{pg_params[14]*100:.3f}%' if pg_params[14] else ''], | |
| ['', '', ''] | |
| ]) | |
| # Predial Residencial (PR) - 15 parameters | |
| param_data.append(['PREDIAL RESIDENCIAL (PR)', '', '']) | |
| pr_params = params[15:30] | |
| param_data.extend([ | |
| ['PR Limite 1 (UFM)', pr_params[0], ''], | |
| ['PR Alíquota 1', pr_params[1], f'{pr_params[1]*100:.3f}%' if pr_params[1] else ''], | |
| ['PR Limite 2 (UFM)', pr_params[2], ''], | |
| ['PR Alíquota 2', pr_params[3], f'{pr_params[3]*100:.3f}%' if pr_params[3] else ''], | |
| ['PR Limite 3 (UFM)', pr_params[4], ''], | |
| ['PR Alíquota 3', pr_params[5], f'{pr_params[5]*100:.3f}%' if pr_params[5] else ''], | |
| ['PR Limite 4 (UFM)', pr_params[6], ''], | |
| ['PR Alíquota 4', pr_params[7], f'{pr_params[7]*100:.3f}%' if pr_params[7] else ''], | |
| ['PR Limite 5 (UFM)', pr_params[8], ''], | |
| ['PR Alíquota 5', pr_params[9], f'{pr_params[9]*100:.3f}%' if pr_params[9] else ''], | |
| ['PR Limite 6 (UFM)', pr_params[10], ''], | |
| ['PR Alíquota 6', pr_params[11], f'{pr_params[11]*100:.3f}%' if pr_params[11] else ''], | |
| ['PR Limite 7 (UFM)', pr_params[12], ''], | |
| ['PR Alíquota 7', pr_params[13], f'{pr_params[13]*100:.3f}%' if pr_params[13] else ''], | |
| ['PR Alíquota 8', pr_params[14], f'{pr_params[14]*100:.3f}%' if pr_params[14] else ''], | |
| ['', '', ''] | |
| ]) | |
| # PNR - 15 parameters | |
| param_data.append(['PREDIAL NÃO RESIDENCIAL (PNR)', '', '']) | |
| pnr_params = params[30:45] | |
| param_data.extend([ | |
| ['PNR Limite 1 (UFM)', pnr_params[0], ''], | |
| ['PNR Alíquota 1', pnr_params[1], f'{pnr_params[1]*100:.3f}%' if pnr_params[1] else ''], | |
| ['PNR Limite 2 (UFM)', pnr_params[2], ''], | |
| ['PNR Alíquota 2', pnr_params[3], f'{pnr_params[3]*100:.3f}%' if pnr_params[3] else ''], | |
| ['PNR Limite 3 (UFM)', pnr_params[4], ''], | |
| ['PNR Alíquota 3', pnr_params[5], f'{pnr_params[5]*100:.3f}%' if pnr_params[5] else ''], | |
| ['PNR Limite 4 (UFM)', pnr_params[6], ''], | |
| ['PNR Alíquota 4', pnr_params[7], f'{pnr_params[7]*100:.3f}%' if pnr_params[7] else ''], | |
| ['PNR Limite 5 (UFM)', pnr_params[8], ''], | |
| ['PNR Alíquota 5', pnr_params[9], f'{pnr_params[9]*100:.3f}%' if pnr_params[9] else ''], | |
| ['PNR Limite 6 (UFM)', pnr_params[10], ''], | |
| ['PNR Alíquota 6', pnr_params[11], f'{pnr_params[11]*100:.3f}%' if pnr_params[11] else ''], | |
| ['PNR Limite 7 (UFM)', pnr_params[12], ''], | |
| ['PNR Alíquota 7', pnr_params[13], f'{pnr_params[13]*100:.3f}%' if pnr_params[13] else ''], | |
| ['PNR Alíquota 8', pnr_params[14], f'{pnr_params[14]*100:.3f}%' if pnr_params[14] else ''], | |
| ['', '', ''] | |
| ]) | |
| # EG, ER, ENR (each 15 parameters) | |
| categories = [ | |
| ('ESTACIONAMENTOS GERAL (EG)', params[45:60], 'EG'), | |
| ('ESTACIONAMENTOS RESIDENCIAIS (ER)', params[60:75], 'ER'), | |
| ('ESTACIONAMENTOS NÃO RESIDENCIAIS (ENR)', params[75:90], 'EN') | |
| ] | |
| for cat_name, cat_params, prefix in categories: | |
| param_data.append([cat_name, '', '']) | |
| param_data.extend([ | |
| [f'{prefix} Limite 1 (UFM)', cat_params[0], ''], | |
| [f'{prefix} Alíquota 1', cat_params[1], f'{cat_params[1]*100:.3f}%' if cat_params[1] else ''], | |
| [f'{prefix} Limite 2 (UFM)', cat_params[2], ''], | |
| [f'{prefix} Alíquota 2', cat_params[3], f'{cat_params[3]*100:.3f}%' if cat_params[3] else ''], | |
| [f'{prefix} Limite 3 (UFM)', cat_params[4], ''], | |
| [f'{prefix} Alíquota 3', cat_params[5], f'{cat_params[5]*100:.3f}%' if cat_params[5] else ''], | |
| [f'{prefix} Limite 4 (UFM)', cat_params[6], ''], | |
| [f'{prefix} Alíquota 4', cat_params[7], f'{cat_params[7]*100:.3f}%' if cat_params[7] else ''], | |
| [f'{prefix} Limite 5 (UFM)', cat_params[8], ''], | |
| [f'{prefix} Alíquota 5', cat_params[9], f'{cat_params[9]*100:.3f}%' if cat_params[9] else ''], | |
| [f'{prefix} Limite 6 (UFM)', cat_params[10], ''], | |
| [f'{prefix} Alíquota 6', cat_params[11], f'{cat_params[11]*100:.3f}%' if cat_params[11] else ''], | |
| [f'{prefix} Limite 7 (UFM)', cat_params[12], ''], | |
| [f'{prefix} Alíquota 7', cat_params[13], f'{cat_params[13]*100:.3f}%' if cat_params[13] else ''], | |
| [f'{prefix} Alíquota 8', cat_params[14], f'{cat_params[14]*100:.3f}%' if cat_params[14] else ''], | |
| ['', '', ''] | |
| ]) | |
| # Terrenos (T1DF, T2DF, T3DF - each 3 parameters) | |
| terreno_categories = [ | |
| ('TERRENOS 1ª DF (T1DF)', params[90:93], '1'), | |
| ('TERRENOS 2ª DF (T2DF)', params[93:96], '2'), | |
| ('TERRENOS 3ª DF (T3DF)', params[96:99], '3') | |
| ] | |
| for cat_name, cat_params, num in terreno_categories: | |
| param_data.append([cat_name, '', '']) | |
| param_data.extend([ | |
| [f'T{num}DF Limite 1 (UFM)', cat_params[0], ''], | |
| [f'T{num}DF Alíquota 1', cat_params[1], f'{cat_params[1]*100:.3f}%' if cat_params[1] else ''], | |
| [f'T{num}DF Alíquota 2', cat_params[2], f'{cat_params[2]*100:.3f}%' if cat_params[2] else ''], | |
| ['', '', ''] | |
| ]) | |
| # TAE and TAF (1 parameter each) | |
| param_data.extend([ | |
| ['TERRENOS ALÍQUOTA ESPECIAL (TAE)', '', ''], | |
| ['TAE Alíquota 1', params[99], f'{params[99]*100:.3f}%' if params[99] else ''], | |
| ['', '', ''], | |
| ['TERRENOS ALÍQUOTA FIXA (TAF)', '', ''], | |
| ['TAF Alíquota 1', params[100], f'{params[100]*100:.3f}%' if params[100] else ''] | |
| ]) | |
| # Create DataFrame | |
| df = pd.DataFrame(param_data, columns=['Parâmetro', 'Valor', 'Percentual']) | |
| return df | |
| def format_worksheet(worksheet, dataframe, currency_columns=None): | |
| """Format worksheet with currency formatting and auto-fit columns""" | |
| from openpyxl.styles import NamedStyle, Font, PatternFill, Alignment | |
| from openpyxl.utils import get_column_letter | |
| if currency_columns is None: | |
| currency_columns = [] | |
| # Create currency style | |
| currency_style = NamedStyle(name="currency_brl") | |
| currency_style.number_format = 'R$ #,##0.00' | |
| # Create header style | |
| header_style = NamedStyle(name="header") | |
| header_style.font = Font(bold=True, color="FFFFFF") | |
| header_style.fill = PatternFill(start_color="366092", end_color="366092", fill_type="solid") | |
| header_style.alignment = Alignment(horizontal="center", vertical="center") | |
| # Apply header formatting | |
| for col_num in range(1, len(dataframe.columns) + 1): | |
| cell = worksheet.cell(row=1, column=col_num) | |
| cell.font = header_style.font | |
| cell.fill = header_style.fill | |
| cell.alignment = header_style.alignment | |
| # Apply currency formatting to specified columns | |
| for col_name in currency_columns: | |
| if col_name in dataframe.columns: | |
| col_idx = dataframe.columns.get_loc(col_name) + 1 # Excel is 1-indexed | |
| col_letter = get_column_letter(col_idx) | |
| # Apply currency format to all data cells in this column (skip header) | |
| for row_num in range(2, len(dataframe) + 2): | |
| cell = worksheet.cell(row=row_num, column=col_idx) | |
| cell.number_format = 'R$ #,##0.00' | |
| # Auto-fit column widths with 10% extra padding | |
| for column in worksheet.columns: | |
| max_length = 0 | |
| column_letter = column[0].column_letter | |
| col_idx = column[0].column - 1 # Convert to 0-based index | |
| # Check if this is a currency column | |
| is_currency_column = False | |
| if col_idx < len(dataframe.columns): | |
| col_name = dataframe.columns[col_idx] | |
| is_currency_column = col_name in currency_columns | |
| for cell in column: | |
| try: | |
| if cell.value: | |
| if is_currency_column and isinstance(cell.value, (int, float)): | |
| # For currency columns, calculate based on formatted display length | |
| # Format: "R$ 1,234,567,890.12" | |
| formatted_value = f"R$ {cell.value:,.2f}" | |
| cell_length = len(formatted_value) | |
| else: | |
| # For non-currency columns, use actual string length | |
| cell_length = len(str(cell.value)) | |
| if cell_length > max_length: | |
| max_length = cell_length | |
| except: | |
| pass | |
| # Set column width with 10% extra padding | |
| adjusted_width = min((max_length + 2) * 1.1, 55) # 10% extra + cap at 55 | |
| worksheet.column_dimensions[column_letter].width = adjusted_width | |
| # Set minimum width for very narrow columns | |
| for col_letter in [get_column_letter(i) for i in range(1, len(dataframe.columns) + 1)]: | |
| if worksheet.column_dimensions[col_letter].width < 12: | |
| worksheet.column_dimensions[col_letter].width = 12 | |
| # --- Function to create Excel file --- | |
| def create_excel_download(df_resumo_iptu, result_agg, total_novo_str, total_atual_trib_str, total_atual_calc_str, | |
| valor_venal_choice, ufm_value, diferencia_estacionamentos_flag, diferencia_predios_flag, all_parameters): | |
| """Create an Excel file with multiple sheets containing the results and parameters""" | |
| # Create a BytesIO object to store the Excel file in memory | |
| output = io.BytesIO() | |
| # Create Excel writer | |
| with pd.ExcelWriter(output, engine='openpyxl') as writer: | |
| # Sheet 1: Detailed summary by category and range | |
| if df_resumo_iptu is not None and not df_resumo_iptu.empty: | |
| # Create a copy without formatting for Excel export | |
| df_export = df_resumo_iptu.copy() | |
| # Convert formatted numbers back to numeric for Excel | |
| if 'Total arrecadado na faixa' in df_export.columns: | |
| df_export['Total arrecadado na faixa'] = df_export['Total arrecadado na faixa'].astype(str).str.replace(',', '').astype(float) | |
| df_export.to_excel(writer, sheet_name='Resumo Detalhado', index=False) | |
| # Format the sheet | |
| worksheet = writer.sheets['Resumo Detalhado'] | |
| format_worksheet(worksheet, df_export, currency_columns=['Total arrecadado na faixa']) | |
| # Sheet 2: Aggregated summary by category | |
| if result_agg is not None and not result_agg.empty: | |
| # Create a copy without formatting for Excel export | |
| result_export = result_agg.copy() | |
| # Convert formatted numbers back to numeric for Excel | |
| total_cols_to_convert = [col for col in result_export.columns if col.startswith("Total")] | |
| for col_name in total_cols_to_convert: | |
| if col_name in result_export.columns: | |
| result_export[col_name] = result_export[col_name].astype(str).str.replace(',', '').astype(float) | |
| result_export.to_excel(writer, sheet_name='Resumo Agregado', index=False) | |
| # Format the sheet | |
| worksheet = writer.sheets['Resumo Agregado'] | |
| currency_cols = [col for col in result_export.columns if col.startswith("Total")] | |
| format_worksheet(worksheet, result_export, currency_columns=currency_cols) | |
| # Sheet 3: Summary totals | |
| summary_data = { | |
| 'Descrição': ['Total IPTU Novo', 'Total IPTU Atual Tributado', 'Total IPTU Atual Calculado'], | |
| 'Valor': [ | |
| float(total_novo_str.split(': ')[1].replace(',', '')) if ': ' in total_novo_str else 0, | |
| float(total_atual_trib_str.split(': ')[1].replace(',', '')) if ': ' in total_atual_trib_str else 0, | |
| float(total_atual_calc_str.split(': ')[1].replace(',', '')) if ': ' in total_atual_calc_str else 0 | |
| ] | |
| } | |
| summary_df = pd.DataFrame(summary_data) | |
| summary_df.to_excel(writer, sheet_name='Totais Gerais', index=False) | |
| # Format the sheet | |
| worksheet = writer.sheets['Totais Gerais'] | |
| format_worksheet(worksheet, summary_df, currency_columns=['Valor']) | |
| # Sheet 4: Parameters and Ranges Used | |
| params_data = create_parameters_sheet(valor_venal_choice, ufm_value, diferencia_estacionamentos_flag, diferencia_predios_flag, all_parameters) | |
| params_data.to_excel(writer, sheet_name='Parâmetros Utilizados', index=False) | |
| # Format the parameters sheet | |
| worksheet = writer.sheets['Parâmetros Utilizados'] | |
| format_worksheet(worksheet, params_data, currency_columns=[]) | |
| output.seek(0) | |
| return output | |
| # --- Main processing function --- | |
| def process_iptu_data( | |
| valor_venal_choice, ufm_value_input, | |
| diferencia_estacionamentos_flag, diferencia_predios_flag, | |
| # Inputs for Faixas e Alíquotas | |
| pg_lim1, pg_alq1, pg_lim2, pg_alq2, pg_lim3, pg_alq3, pg_lim4, pg_alq4, pg_lim5, pg_alq5, pg_lim6, pg_alq6, pg_lim7, pg_alq7, pg_alq8, | |
| pr_lim1, pr_alq1, pr_lim2, pr_alq2, pr_lim3, pr_alq3, pr_lim4, pr_alq4, pr_lim5, pr_alq5, pr_lim6, pr_alq6, pr_lim7, pr_alq7, pr_alq8, | |
| pnr_lim1, pnr_alq1, pnr_lim2, pnr_alq2, pnr_lim3, pnr_alq3, pnr_lim4, pnr_alq4, pnr_lim5, pnr_alq5, pnr_lim6, pnr_alq6, pnr_lim7, pnr_alq7, pnr_alq8, | |
| eg_lim1, eg_alq1, eg_lim2, eg_alq2, eg_lim3, eg_alq3, eg_lim4, eg_alq4, eg_lim5, eg_alq5, eg_lim6, eg_alq6, eg_lim7, eg_alq7, eg_alq8, | |
| er_lim1, er_alq1, er_lim2, er_alq2, er_lim3, er_alq3, er_lim4, er_alq4, er_lim5, er_alq5, er_lim6, er_alq6, er_lim7, er_alq7, er_alq8, | |
| enr_lim1, enr_alq1, enr_lim2, enr_alq2, enr_lim3, enr_alq3, enr_lim4, enr_alq4, enr_lim5, enr_alq5, enr_lim6, enr_alq6, enr_lim7, enr_alq7, enr_alq8, | |
| t1df_lim1, t1df_alq1, t1df_alq2, | |
| t2df_lim1, t2df_alq1, t2df_alq2, | |
| t3df_lim1, t3df_alq1, t3df_alq2, | |
| tae_alq1, | |
| taf_alq1 | |
| ): | |
| # === CSV LOADING AND VALIDATION === | |
| if not os.path.exists(CSV_FILE_PATH): | |
| return f"Erro: Arquivo '{CSV_FILE_PATH}' não encontrado no servidor.", None, None, "", "", "", gr.Textbox(visible=False), gr.DownloadButton(visible=False) | |
| try: | |
| the_merge = pd.read_csv(CSV_FILE_PATH) | |
| except Exception as e: | |
| return f"Erro ao ler o arquivo CSV '{CSV_FILE_PATH}': {str(e)}", None, None, "", "", "", gr.Textbox(visible=False), gr.DownloadButton(visible=False) | |
| valor_venal_utilizado = valor_venal_choice | |
| UFM_VALUE = ufm_value_input | |
| required_cols = ["TIPO_LANCAMENTO", "DES_TIPO_ISENCAO_MULTI", "VLR_IMPOSTO_iptu", | |
| "DES_FINALIDADE_unidade", "DES_USO_unidade", "IDF_TIPO_BENEFICIO", | |
| "NUM_DIVISAO_FISCAL_iptu", valor_venal_utilizado, | |
| "VLR_IMPOSTO_CALCULADO_iptu"] | |
| missing_cols = [col for col in required_cols if col not in the_merge.columns] | |
| if missing_cols: | |
| return f"Colunas ausentes no CSV: {', '.join(missing_cols)}", None, None, "", "", "", gr.Textbox(visible=False), gr.DownloadButton(visible=False) | |
| for col_str in ["TIPO_LANCAMENTO", "DES_TIPO_ISENCAO_MULTI", "DES_FINALIDADE_unidade", "DES_USO_unidade"]: | |
| if col_str in the_merge.columns: | |
| the_merge[col_str] = the_merge[col_str].astype(str).fillna('') | |
| # === PARAMETER ASSIGNMENT === | |
| # [All parameter assignments remain exactly the same as before] | |
| PG_lim_1, PG_aliq_1 = pg_lim1, pg_alq1; PG_lim_2, PG_aliq_2 = pg_lim2, pg_alq2; PG_lim_3, PG_aliq_3 = pg_lim3, pg_alq3; PG_lim_4, PG_aliq_4 = pg_lim4, pg_alq4; PG_lim_5, PG_aliq_5 = pg_lim5, pg_alq5; PG_lim_6, PG_aliq_6 = pg_lim6, pg_alq6; PG_lim_7, PG_aliq_7 = pg_lim7, pg_alq7; PG_aliq_8 = pg_alq8 | |
| PR_lim_1, PR_aliq_1 = pr_lim1, pr_alq1; PR_lim_2, PR_aliq_2 = pr_lim2, pr_alq2; PR_lim_3, PR_aliq_3 = pr_lim3, pr_alq3; PR_lim_4, PR_aliq_4 = pr_lim4, pr_alq4; PR_lim_5, PR_aliq_5 = pr_lim5, pr_alq5; PR_lim_6, PR_aliq_6 = pr_lim6, pr_alq6; PR_lim_7, PR_aliq_7 = pr_lim7, pr_alq7; PR_aliq_8 = pr_alq8 | |
| PNR_lim_1, PNR_aliq_1 = pnr_lim1, pnr_alq1; PNR_lim_2, PNR_aliq_2 = pnr_lim2, pnr_alq2; PNR_lim_3, PNR_aliq_3 = pnr_lim3, pnr_alq3; PNR_lim_4, PNR_aliq_4 = pnr_lim4, pnr_alq4; PNR_lim_5, PNR_aliq_5 = pnr_lim5, pnr_alq5; PNR_lim_6, PNR_aliq_6 = pnr_lim6, pnr_alq6; PNR_lim_7, PNR_aliq_7 = pnr_lim7, pnr_alq7; PNR_aliq_8 = pnr_alq8 | |
| EG_lim_1, EG_aliq_1 = eg_lim1, eg_alq1; EG_lim_2, EG_aliq_2 = eg_lim2, eg_alq2; EG_lim_3, EG_aliq_3 = eg_lim3, eg_alq3; EG_lim_4, EG_aliq_4 = eg_lim4, eg_alq4; EG_lim_5, EG_aliq_5 = eg_lim5, eg_alq5; EG_lim_6, EG_aliq_6 = eg_lim6, eg_alq6; EG_lim_7, EG_aliq_7 = eg_lim7, eg_alq7; EG_aliq_8 = eg_alq8 | |
| ER_lim_1, ER_aliq_1 = er_lim1, er_alq1; ER_lim_2, ER_aliq_2 = er_lim2, er_alq2; ER_lim_3, ER_aliq_3 = er_lim3, er_alq3; ER_lim_4, ER_aliq_4 = er_lim4, er_alq4; ER_lim_5, ER_aliq_5 = er_lim5, er_alq5; ER_lim_6, ER_aliq_6 = er_lim6, er_alq6; ER_lim_7, ER_aliq_7 = er_lim7, er_alq7; ER_aliq_8 = er_alq8 | |
| ENR_lim_1, ENR_aliq_1 = enr_lim1, enr_alq1; ENR_lim_2, ENR_aliq_2 = enr_lim2, enr_alq2; ENR_lim_3, ENR_aliq_3 = enr_lim3, enr_alq3; ENR_lim_4, ENR_aliq_4 = enr_lim4, enr_alq4; ENR_lim_5, ENR_aliq_5 = enr_lim5, enr_alq5; ENR_lim_6, ENR_aliq_6 = enr_lim6, enr_alq6; ENR_lim_7, ENR_aliq_7 = enr_lim7, enr_alq7; ENR_aliq_8 = enr_alq8 | |
| T1DF_lim_1, T1DF_aliq_1 = t1df_lim1, t1df_alq1; T1DF_aliq_2 = t1df_alq2 | |
| T2DF_lim_1, T2DF_aliq_1 = t2df_lim1, t2df_alq1; T2DF_aliq_2 = t2df_alq2 | |
| T3DF_lim_1, T3DF_aliq_1 = t3df_lim1, t3df_alq1; T3DF_aliq_2 = t3df_alq2 | |
| TAE_aliq_1 = tae_alq1 | |
| TAF_aliq_1 = taf_alq1 | |
| # === DATA FILTERING AND CLASSIFICATION === | |
| # [All filtering logic remains exactly the same as before] | |
| sem_lancamento = (the_merge["TIPO_LANCAMENTO"].isin(['Isenção Total por Benefício Fiscal', 'Imóvel com bloqueio de lançamento de IPTU/TCL', 'Não lançado - Valor total calculado menor que o mínimo', 'Isenção TCL Box e Não Lançado - valor menor que Mínimo', 'Isenção Técnica'])) | ((the_merge["TIPO_LANCAMENTO"]=='Isenção TCL - Box') & (the_merge["VLR_IMPOSTO_iptu"]==0)) | |
| isentos = (the_merge["DES_TIPO_ISENCAO_MULTI"].str.contains("isen", case=False, na=False)) | |
| imunes = (the_merge["DES_TIPO_ISENCAO_MULTI"].str.contains("imun", case=False, na=False)) | (the_merge["DES_TIPO_ISENCAO_MULTI"].str.contains("IMUNIDADES", na=False)) | |
| nao_incidencia = (the_merge["DES_TIPO_ISENCAO_MULTI"].str.contains("NÃO INCIDÊNCIA DE IPTU", case=False, na=False)) | |
| nao_tributados = (isentos) | (imunes) | (sem_lancamento) | (nao_incidencia) | |
| # Property type classifications [Same as before] | |
| finalidades_estacionamentos = ['ESPACO DE ESTACIONAMENTO RESIDENCIAL', 'ESPACO DE ESTACIONAMENTO NAO RESIDENCIAL', 'ESPACO ESTACIONAMENTO VINCULADO NAO RESID DESCOBERTO', 'ESPACO ESTACIONAMENTO VINCULADO RESID COBERTO', 'ESPACO ESTACIONAMENTO VINCULADO NAO RESID COBERTO', 'ESPACO DE ESTACIONAMENTO RESIDENCIAL DESCOBERTO', 'ESPACO DE ESTACIONAMENTO NAO RESIDENC DESCOBERTO', 'ESPACO ESTACIONAMENTO VINCULADO RESID DESCOBERTO'] | |
| finalidades_terrenos = ['TERRENO', 'GLEBA', 'TERRENOS CONDOMINIO HORIZ ABERTO SEM AREA USO COMUM', 'TERRENO EM CONDOMINIO HORIZONTAL FECHADO', 'TERRENO EM CONDOMINIO HORIZONTAL ABERTO', 'SOBRA DE AREA', 'AREA A VISTORIAR'] | |
| # All property classifications [Same logic as before] | |
| estacionamentos_residenciais = (the_merge["DES_FINALIDADE_unidade"].isin(finalidades_estacionamentos)) & (the_merge["DES_USO_unidade"]=='Exclusivamente Residencial') | |
| estacionamentos_residenciais_tributados = (estacionamentos_residenciais) & (~nao_tributados) | |
| estacionamentos_residenciais_nao_tributados = (estacionamentos_residenciais) & (nao_tributados) | |
| estacionamentos_nao_residenciais = (the_merge["DES_FINALIDADE_unidade"].isin(finalidades_estacionamentos)) & (the_merge["DES_USO_unidade"]!='Exclusivamente Residencial') | |
| estacionamentos_nao_residenciais_tributados = (estacionamentos_nao_residenciais) & (~nao_tributados) | |
| estacionamentos_nao_residenciais_nao_tributados = (estacionamentos_nao_residenciais) & (nao_tributados) | |
| estacionamentos_geral = the_merge["DES_FINALIDADE_unidade"].isin(finalidades_estacionamentos) | |
| estacionamentos_geral_tributados = (estacionamentos_geral) & (~nao_tributados) | |
| estacionamentos_geral_nao_tributados = (estacionamentos_geral) & (nao_tributados) | |
| terrenos_aliqesp = (the_merge["DES_FINALIDADE_unidade"].isin(finalidades_terrenos)) & (pd.to_numeric(the_merge["IDF_TIPO_BENEFICIO"], errors="coerce").fillna(0).astype(int) == 301) & (~nao_tributados) | |
| terrenos_aliqfix = (the_merge["DES_FINALIDADE_unidade"].isin(finalidades_terrenos)) & (pd.to_numeric(the_merge["IDF_TIPO_BENEFICIO"], errors="coerce").fillna(0).astype(int) == 95) & (~nao_tributados) | |
| terrenos_1df = (the_merge["DES_FINALIDADE_unidade"].isin(finalidades_terrenos)) & (the_merge["NUM_DIVISAO_FISCAL_iptu"]==1) & (~terrenos_aliqesp) & (~terrenos_aliqfix) | |
| terrenos_1df_tributados = (terrenos_1df) & (~nao_tributados) | |
| terrenos_1df_nao_tributados = (terrenos_1df) & (nao_tributados) | |
| terrenos_2df = (the_merge["DES_FINALIDADE_unidade"].isin(finalidades_terrenos)) & (the_merge["NUM_DIVISAO_FISCAL_iptu"]==2) & (~terrenos_aliqesp) & (~terrenos_aliqfix) | |
| terrenos_2df_tributados = (terrenos_2df) & (~nao_tributados) | |
| terrenos_2df_nao_tributados = (terrenos_2df) & (nao_tributados) | |
| terrenos_3df = (the_merge["DES_FINALIDADE_unidade"].isin(finalidades_terrenos)) & (the_merge["NUM_DIVISAO_FISCAL_iptu"]==3) & (~terrenos_aliqesp) & (~terrenos_aliqfix) | |
| terrenos_3df_tributados = (terrenos_3df) & (~nao_tributados) | |
| terrenos_3df_nao_tributados = (terrenos_3df) & (nao_tributados) | |
| isen_prop_loc = ((the_merge["DES_TIPO_ISENCAO_MULTI"] == 'ISENÇÃO - PROPRIETARIO/USUFRUTUARIO APOSENTADO, INATIVO, PENSIONISTA') | (the_merge["DES_TIPO_ISENCAO_MULTI"] == 'ISENÇÃO - LOCATÁRIO/COMODATARIO/ARRENDATÁRIO APOSENTADO, INATIVO, PENSIONISTA')| (the_merge["DES_TIPO_ISENCAO_MULTI"] == 'ISENÇÃO - PROPRIETARIO/USUFRUTUARIO DEFICIENTE')) | |
| isen_hab_pop = ((the_merge["DES_TIPO_ISENCAO_MULTI"] == 'ISENÇÃO - HABITAÇÕES POPULARES DE EMPREENDIMENTOS HABITACIONAIS DESTINADOS PARA HABITAÇÃO DE INTERESSE SOCIAL') | (the_merge["DES_TIPO_ISENCAO_MULTI"] == 'ISENÇÃO - HABITAÇÕES POPULARES ORIUNDAS DE REGULARIZAÇÕES FUNDIÁRIAS PROMOVIDAS POR ÓRGÃOS PÚBLICOS')) | |
| prediais_residenciais = (~the_merge["DES_FINALIDADE_unidade"].isin(finalidades_estacionamentos + finalidades_terrenos)) & (the_merge["DES_USO_unidade"] == 'Exclusivamente Residencial') | |
| prediais_residenciais_tributados = (prediais_residenciais) & (~nao_tributados) & (~isen_prop_loc) & (~isen_hab_pop) | |
| prediais_residenciais_nao_tributados = (prediais_residenciais) & (nao_tributados) & (~isen_prop_loc) & (~isen_hab_pop) | |
| prediais_nao_residenciais = (~the_merge["DES_FINALIDADE_unidade"].isin(finalidades_estacionamentos + finalidades_terrenos)) & (the_merge["DES_USO_unidade"] != 'Exclusivamente Residencial') & (~isen_prop_loc) & (~isen_hab_pop) | |
| prediais_nao_residenciais_tributados = (prediais_nao_residenciais) & (~nao_tributados) & (~isen_prop_loc) & (~isen_hab_pop) | |
| prediais_nao_residenciais_nao_tributados = (prediais_nao_residenciais) & (nao_tributados) & (~isen_prop_loc) & (~isen_hab_pop) | |
| prediais_geral = (~the_merge["DES_FINALIDADE_unidade"].isin(finalidades_estacionamentos + finalidades_terrenos)) & (~isen_prop_loc) & (~isen_hab_pop) | |
| prediais_geral_tributados = (prediais_geral) & (~nao_tributados) & (~isen_prop_loc) & (~isen_hab_pop) | |
| prediais_geral_nao_tributados = (prediais_geral) & (nao_tributados) & (~isen_prop_loc) & (~isen_hab_pop) | |
| # === IPTU RULES DEFINITION === | |
| IPTU_RULES = { | |
| 'PGI': { 'name': "Predial Sem Dif. por Uso Isentos", 'rule': prediais_geral_nao_tributados, 'ranges': [[np.inf, 0.0]]}, | |
| 'PG': { 'name': "Predial Sem Dif. por Uso", 'rule': prediais_geral_tributados, 'ranges': [[PG_lim_1*UFM_VALUE, PG_aliq_1],[PG_lim_2*UFM_VALUE, PG_aliq_2],[PG_lim_3*UFM_VALUE, PG_aliq_3],[PG_lim_4*UFM_VALUE, PG_aliq_4],[PG_lim_5*UFM_VALUE, PG_aliq_5],[PG_lim_6*UFM_VALUE, PG_aliq_6],[PG_lim_7*UFM_VALUE, PG_aliq_7],[np.inf, PG_aliq_8]]}, | |
| 'PRI': { 'name': "Predial Residencial Isentos", 'rule': prediais_residenciais_nao_tributados, 'ranges': [[np.inf, 0.0]]}, | |
| 'PR': { 'name': "Predial Residencial", 'rule': prediais_residenciais_tributados, 'ranges': [[PR_lim_1*UFM_VALUE, PR_aliq_1],[PR_lim_2*UFM_VALUE, PR_aliq_2],[PR_lim_3*UFM_VALUE, PR_aliq_3],[PR_lim_4*UFM_VALUE, PR_aliq_4],[PR_lim_5*UFM_VALUE, PR_aliq_5],[PR_lim_6*UFM_VALUE, PR_aliq_6],[PR_lim_7*UFM_VALUE, PR_aliq_7],[np.inf, PR_aliq_8]]}, | |
| 'PNRI': { 'name': "Predial Não Residencial Isentos", 'rule': prediais_nao_residenciais_nao_tributados, 'ranges': [[np.inf, 0.0]]}, | |
| 'PNR': { 'name': "Predial Não Residencial", 'rule': prediais_nao_residenciais_tributados, 'ranges': [[PNR_lim_1*UFM_VALUE, PNR_aliq_1],[PNR_lim_2*UFM_VALUE, PNR_aliq_2],[PNR_lim_3*UFM_VALUE, PNR_aliq_3],[PNR_lim_4*UFM_VALUE, PNR_aliq_4],[PNR_lim_5*UFM_VALUE, PNR_aliq_5],[PNR_lim_6*UFM_VALUE, PNR_aliq_6],[PNR_lim_7*UFM_VALUE, PNR_aliq_7],[np.inf, PNR_aliq_8]]}, | |
| 'EGI': { 'name':'Estacionamentos Sem Dif. por Uso Isentos', 'rule': estacionamentos_geral_nao_tributados, 'ranges': [[np.inf, 0.0]]}, | |
| 'EG': { 'name': "Estacionamentos Sem Dif. por Uso", 'rule': estacionamentos_geral_tributados, 'ranges': [[EG_lim_1*UFM_VALUE, EG_aliq_1],[EG_lim_2*UFM_VALUE, EG_aliq_2],[EG_lim_3*UFM_VALUE, EG_aliq_3],[EG_lim_4*UFM_VALUE, EG_aliq_4],[EG_lim_5*UFM_VALUE, EG_aliq_5],[EG_lim_6*UFM_VALUE, EG_aliq_6],[EG_lim_7*UFM_VALUE, EG_aliq_7],[np.inf, EG_aliq_8]]}, | |
| 'ERI': { 'name':'Estacionamentos Residenciais Isentos', 'rule': estacionamentos_residenciais_nao_tributados, 'ranges': [[np.inf, 0.0]]}, | |
| 'ER': { 'name':'Estacionamentos Residenciais', 'rule': estacionamentos_residenciais_tributados, 'ranges': [[ER_lim_1*UFM_VALUE, ER_aliq_1],[ER_lim_2*UFM_VALUE, ER_aliq_2],[ER_lim_3*UFM_VALUE, ER_aliq_3],[ER_lim_4*UFM_VALUE, ER_aliq_4],[ER_lim_5*UFM_VALUE, ER_aliq_5],[ER_lim_6*UFM_VALUE, ER_aliq_6],[ER_lim_7*UFM_VALUE, ER_aliq_7],[np.inf, ER_aliq_8]]}, | |
| 'ENRI': { 'name':'Estacionamentos Não Residenciais Isentos', 'rule': estacionamentos_nao_residenciais_nao_tributados, 'ranges': [[np.inf, 0.0]]}, | |
| 'ENR': { 'name':'Estacionamentos Não Residenciais', 'rule': estacionamentos_nao_residenciais_tributados, 'ranges': [[ENR_lim_1*UFM_VALUE, ENR_aliq_1],[ENR_lim_2*UFM_VALUE, ENR_aliq_2],[ENR_lim_3*UFM_VALUE, ENR_aliq_3],[ENR_lim_4*UFM_VALUE, ENR_aliq_4],[ENR_lim_5*UFM_VALUE, ENR_aliq_5],[ENR_lim_6*UFM_VALUE, ENR_aliq_6],[ENR_lim_7*UFM_VALUE, ENR_aliq_7],[np.inf, ENR_aliq_8]]}, | |
| 'T1DFI': { 'name':'Terrenos na 1a DF Isentos', 'rule': terrenos_1df_nao_tributados, 'ranges': [[np.inf, 0.0]]}, | |
| 'T1DF': { 'name': 'Terrenos na 1a DF', 'rule': terrenos_1df_tributados, 'ranges': [[T1DF_lim_1*UFM_VALUE, T1DF_aliq_1],[np.inf, T1DF_aliq_2]]}, | |
| 'T2DFI': { 'name':'Terrenos na 2a DF Isentos', 'rule': terrenos_2df_nao_tributados, 'ranges': [[np.inf, 0.0]]}, | |
| 'T2DF': { 'name': 'Terrenos na 2a DF', 'rule': terrenos_2df_tributados, 'ranges': [[T2DF_lim_1*UFM_VALUE, T2DF_aliq_1],[np.inf, T2DF_aliq_2]]}, | |
| 'T3DFI': { 'name':'Terrenos na 3a DF Isentos', 'rule': terrenos_3df_nao_tributados, 'ranges': [[np.inf, 0.0]]}, | |
| 'T3DF': { 'name': 'Terrenos na 3a DF', 'rule': terrenos_3df_tributados, 'ranges': [[T3DF_lim_1*UFM_VALUE, T3DF_aliq_1],[np.inf, T3DF_aliq_2]]}, | |
| 'TAE': { 'name': 'Terrenos Aliq. Esp.', 'rule': terrenos_aliqesp, 'ranges': [[np.inf, TAE_aliq_1]]}, | |
| 'TAF': { 'name': 'Terrenos Aliq. Fix.', 'rule': terrenos_aliqfix, 'ranges': [[np.inf, TAF_aliq_1]]}, | |
| } | |
| # Rule filtering based on differentiation flags [Same logic as before] | |
| if diferencia_estacionamentos_flag: | |
| if 'EG' in IPTU_RULES: del IPTU_RULES['EG'] | |
| if 'EGI' in IPTU_RULES: del IPTU_RULES['EGI'] | |
| else: | |
| if 'ER' in IPTU_RULES: del IPTU_RULES['ER'] | |
| if 'ERI' in IPTU_RULES: del IPTU_RULES['ERI'] | |
| if 'ENR' in IPTU_RULES: del IPTU_RULES['ENR'] | |
| if 'ENRI' in IPTU_RULES: del IPTU_RULES['ENRI'] | |
| if diferencia_predios_flag: | |
| if 'PG' in IPTU_RULES: del IPTU_RULES['PG'] | |
| if 'PGI' in IPTU_RULES: del IPTU_RULES['PGI'] | |
| else: | |
| if 'PR' in IPTU_RULES: del IPTU_RULES['PR'] | |
| if 'PRI' in IPTU_RULES: del IPTU_RULES['PRI'] | |
| if 'PNR' in IPTU_RULES: del IPTU_RULES['PNR'] | |
| if 'PNRI' in IPTU_RULES: del IPTU_RULES['PNRI'] | |
| reference_rule_key = 'PR' if diferencia_predios_flag else 'PG' | |
| if reference_rule_key not in IPTU_RULES: | |
| if 'PG' in IPTU_RULES: reference_rule_key = 'PG' | |
| elif 'PR' in IPTU_RULES: reference_rule_key = 'PR' | |
| else: return f"Erro: Nenhuma regra de referência Predial (PG/PR) disponível.", None, None, "", "", "", gr.Textbox(visible=False), gr.DownloadButton(visible=False) | |
| reference_rule = IPTU_RULES[reference_rule_key] | |
| # Special rules for exemptions [Same logic as before] | |
| prpl_ranges = [[100000 * UFM_VALUE, 0.0]] | |
| if reference_rule['ranges'][0][0] >= 100000 * UFM_VALUE: prpl_ranges = reference_rule['ranges'].copy() | |
| else: | |
| for threshold, rate in reference_rule['ranges']: | |
| if threshold > 100000 * UFM_VALUE: prpl_ranges.append([threshold, rate]) | |
| IPTU_RULES['PRPL'] = {'name': "Predial Residencial - Aposentado, Inativo, Pensionista, Deficiente", 'rule': isen_prop_loc, 'ranges': prpl_ranges} | |
| prph_ranges = [[55000 * UFM_VALUE, 0.0]] | |
| if reference_rule['ranges'][0][0] >= 55000 * UFM_VALUE: prph_ranges = reference_rule['ranges'].copy() | |
| else: | |
| for threshold, rate in reference_rule['ranges']: | |
| if threshold > 55000 * UFM_VALUE: prph_ranges.append([threshold, rate]) | |
| IPTU_RULES['PRHP'] = {'name': "Predial Residencial - Habitações Populares", 'rule': isen_hab_pop, 'ranges': prph_ranges} | |
| # === TAX CALCULATION ENGINE === | |
| # [All calculation logic remains exactly the same as before] | |
| the_merge[valor_venal_utilizado] = pd.to_numeric(the_merge[valor_venal_utilizado], errors='coerce') | |
| for regra_nome, regra in IPTU_RULES.items(): | |
| filtro = regra["rule"] | |
| faixas = regra["ranges"] | |
| current_vv_values = the_merge.loc[filtro, valor_venal_utilizado] | |
| limites = [0] + [lim[0] for lim in faixas] | |
| aliquotas = [lim[1] for lim in faixas] | |
| for i in range(len(aliquotas)): | |
| limite_inferior = limites[i] | |
| limite_superior = limites[i + 1] if i + 1 < len(limites) else float('inf') | |
| aliquota = aliquotas[i] | |
| nome_coluna = f"IPTU_{regra_nome}_F{i+1}" | |
| valor_na_banda = np.maximum(0, np.minimum(current_vv_values, limite_superior) - limite_inferior) | |
| if limite_superior == float('inf'): | |
| valor_na_banda = np.maximum(0, current_vv_values - limite_inferior) | |
| imposto_na_banda = valor_na_banda * aliquota | |
| the_merge.loc[filtro, nome_coluna] = imposto_na_banda | |
| new_total_columns = {} | |
| for chave, regra in IPTU_RULES.items(): | |
| colunas_faixas = [f"IPTU_{chave}_F{i+1}" for i in range(len(regra["ranges"]))] | |
| for col_f in colunas_faixas: | |
| if col_f not in the_merge.columns: the_merge[col_f] = 0 | |
| if not colunas_faixas: new_total_columns[f"IPTU_{chave}_TOTAL"] = pd.Series(0, index=the_merge.index) | |
| else: new_total_columns[f"IPTU_{chave}_TOTAL"] = the_merge[colunas_faixas].fillna(0).sum(axis=1) | |
| the_merge = pd.concat([the_merge, pd.DataFrame(new_total_columns, index=the_merge.index)], axis=1) | |
| # === RESULTS GENERATION === | |
| # [All results generation logic remains exactly the same as before] | |
| resumo_total = [] | |
| for regra_nome, regra in IPTU_RULES.items(): | |
| nome_legivel = regra["name"]; filtro_rule = regra["rule"]; faixas = regra["ranges"] | |
| df_filtrado = the_merge[filtro_rule].copy() | |
| vv_perc = df_filtrado[valor_venal_utilizado] | |
| limites_faixas = [lim[0] for lim in faixas]; limites_com_zero = [0] + limites_faixas; aliquotas_faixas = [lim[1] for lim in faixas] | |
| for i, (limite_superior_raw, aliquota) in enumerate(faixas): | |
| limite_superior_display = limite_superior_raw if limite_superior_raw != np.inf else float('inf') | |
| faixa_col = f"IPTU_{regra_nome}_F{i+1}" | |
| if faixa_col not in df_filtrado.columns: df_filtrado[faixa_col] = 0 | |
| faixa_nome_val_inf = limite_superior_display/UFM_VALUE if UFM_VALUE != 0 else float('inf') | |
| faixa_nome = f"{limites_com_zero[i]/UFM_VALUE if UFM_VALUE !=0 else 0:,.0f} a {faixa_nome_val_inf:,.0f} UFM ({aliquota*100:.2f}%)" | |
| if limite_superior_display == float('inf'): faixa_nome = f"{limites_com_zero[i]/UFM_VALUE if UFM_VALUE != 0 else 0:,.0f} a inf UFM ({aliquota*100:.2f}%)" | |
| total_faixa = df_filtrado[faixa_col].fillna(0).sum() | |
| cond_exclusiva = pd.Series(False, index=vv_perc.index) | |
| if not vv_perc.empty: | |
| if i == 0: cond_exclusiva = vv_perc <= limite_superior_raw | |
| else: cond_exclusiva = (vv_perc > limites_com_zero[i]) & (vv_perc <= limite_superior_raw) | |
| qnt_exclusiva = cond_exclusiva.sum() | |
| cond_atinge = pd.Series(False, index=vv_perc.index) | |
| if not vv_perc.empty: cond_atinge = vv_perc > limites_com_zero[i] | |
| qnt_atinge = cond_atinge.sum() | |
| resumo_total.append([nome_legivel, faixa_nome, qnt_exclusiva, qnt_atinge, total_faixa]) | |
| df_resumo_iptu = pd.DataFrame(resumo_total, columns=["Categoria", "Faixa (VV em UFM)", "Inscrições apenas nesta faixa", "Inscrições que atingem esta faixa", "Total arrecadado na faixa"]) | |
| df_resumo_iptu.reset_index(drop=True, inplace=True) | |
| # Aggregation and normalization logic [Same as before] | |
| df = df_resumo_iptu.copy() | |
| temp_cat_col = df["Categoria"].astype(str) | |
| if diferencia_predios_flag: | |
| temp_cat_col = temp_cat_col.str.replace(r" - Aposentado, Inativo, Pensionista, Deficiente$", "", regex=True) | |
| temp_cat_col = temp_cat_col.str.replace(r" - Habitações Populares$", "", regex=True) | |
| else: | |
| predial_pattern = r"Predial (Residencial|Não Residencial|Sem Dif\. por Uso)( - Aposentado, Inativo, Pensionista, Deficiente| - Habitações Populares| Isentos)?$" | |
| temp_cat_col = temp_cat_col.str.replace(predial_pattern, "Predial Sem Dif. por Uso", regex=True) | |
| temp_cat_col = temp_cat_col.str.replace(r" Isentos$", "", regex=True) | |
| df["CategoriaNormalizada"] = temp_cat_col | |
| df["Total arrecadado na faixa"] = pd.to_numeric(df["Total arrecadado na faixa"], errors="coerce").fillna(0) | |
| result_agg = df.groupby("CategoriaNormalizada", as_index=False).agg({"Inscrições apenas nesta faixa": "sum", "Total arrecadado na faixa": "sum"}).rename(columns={"CategoriaNormalizada": "Categoria", "Inscrições apenas nesta faixa": "Inscrições", "Total arrecadado na faixa": "Total IPTU Novo"}) | |
| # Current tax totals calculation [Same as before] | |
| total_imposto_atual, total_imposto_calculado, inscricoes_com_iptu = {}, {}, {} | |
| for regra_nome, regra in IPTU_RULES.items(): | |
| nome_legivel = regra["name"] | |
| nome_normalizado = str(nome_legivel) | |
| if diferencia_predios_flag: | |
| nome_normalizado = nome_normalizado.replace(" - Aposentado, Inativo, Pensionista, Deficiente", "") | |
| nome_normalizado = nome_normalizado.replace(" - Habitações Populares", "") | |
| else: | |
| if "Predial Residencial" in nome_normalizado or "Predial Não Residencial" in nome_normalizado or "Predial Sem Dif. por Uso" in nome_normalizado : | |
| nome_normalizado = "Predial Sem Dif. por Uso" | |
| nome_normalizado = nome_normalizado.replace(" Isentos", "") | |
| filtro_rule = regra["rule"] | |
| total_imposto_atual[nome_normalizado] = total_imposto_atual.get(nome_normalizado, 0) + the_merge.loc[filtro_rule, "VLR_IMPOSTO_iptu"].fillna(0).sum() | |
| total_imposto_calculado[nome_normalizado] = total_imposto_calculado.get(nome_normalizado, 0) + the_merge.loc[filtro_rule, "VLR_IMPOSTO_CALCULADO_iptu"].fillna(0).sum() | |
| inscricoes_com_iptu[nome_normalizado] = inscricoes_com_iptu.get(nome_normalizado, 0) + (the_merge.loc[filtro_rule, "VLR_IMPOSTO_iptu"].fillna(0) > 0).sum() | |
| result_agg["Total IPTU Atual Tributado"] = result_agg["Categoria"].map(total_imposto_atual).fillna(0) | |
| result_agg["Total IPTU Atual Calculado"] = result_agg["Categoria"].map(total_imposto_calculado).fillna(0) | |
| result_agg["Inscrições com IPTU > 0"] = result_agg["Categoria"].map(inscricoes_com_iptu).fillna(0) | |
| # Final filtering [Same as before] | |
| if diferencia_estacionamentos_flag: result_agg = result_agg[result_agg["Categoria"] != "Estacionamentos Sem Dif. por Uso"] | |
| else: result_agg = result_agg[~result_agg["Categoria"].isin(["Estacionamentos Não Residenciais", "Estacionamentos Residenciais"])] | |
| if diferencia_predios_flag: result_agg = result_agg[result_agg["Categoria"] != "Predial Sem Dif. por Uso"] | |
| else: result_agg = result_agg[~result_agg["Categoria"].isin(["Predial Não Residencial", "Predial Residencial"])] | |
| cols_order = ["Categoria", "Inscrições", "Inscrições com IPTU > 0", "Total IPTU Novo", "Total IPTU Atual Tributado", "Total IPTU Atual Calculado"] | |
| current_cols = [col for col in cols_order if col in result_agg.columns] | |
| result_agg = result_agg[current_cols] | |
| # === FORMATTING FOR DISPLAY === | |
| if 'Total arrecadado na faixa' in df_resumo_iptu.columns: | |
| df_resumo_iptu['Total arrecadado na faixa'] = df_resumo_iptu['Total arrecadado na faixa'].apply(lambda x: f"{x:,.2f}" if pd.notnull(x) else x) | |
| total_cols_to_format = [col for col in result_agg.columns if col.startswith("Total")] | |
| for col_name in total_cols_to_format: | |
| if result_agg[col_name].dtype == float or result_agg[col_name].dtype == np.float64: | |
| result_agg[col_name] = result_agg[col_name].apply(lambda x: f"{x:,.2f}" if pd.notnull(x) else x) | |
| # Calculate summary totals | |
| total_novo_sum = pd.to_numeric(result_agg['Total IPTU Novo'].str.replace(',', ''), errors='coerce').sum() | |
| total_atual_trib_sum = pd.to_numeric(result_agg['Total IPTU Atual Tributado'].str.replace(',', ''), errors='coerce').sum() | |
| total_atual_calc_sum = pd.to_numeric(result_agg['Total IPTU Atual Calculado'].str.replace(',', ''), errors='coerce').sum() | |
| total_novo_str = f"Total IPTU Novo: {total_novo_sum:,.2f}" | |
| total_atual_trib_str = f"Total IPTU Atual Tributado: {total_atual_trib_sum:,.2f}" | |
| total_atual_calc_str = f"Total IPTU Atual Calculado: {total_atual_calc_sum:,.2f}" | |
| # === EXCEL FILE GENERATION === | |
| filename_text = "" | |
| download_button_result = gr.DownloadButton(visible=False) | |
| try: | |
| # Collect all parameters for the Excel export | |
| all_parameters = [ | |
| pg_lim1, pg_alq1, pg_lim2, pg_alq2, pg_lim3, pg_alq3, pg_lim4, pg_alq4, pg_lim5, pg_alq5, pg_lim6, pg_alq6, pg_lim7, pg_alq7, pg_alq8, | |
| pr_lim1, pr_alq1, pr_lim2, pr_alq2, pr_lim3, pr_alq3, pr_lim4, pr_alq4, pr_lim5, pr_alq5, pr_lim6, pr_alq6, pr_lim7, pr_alq7, pr_alq8, | |
| pnr_lim1, pnr_alq1, pnr_lim2, pnr_alq2, pnr_lim3, pnr_alq3, pnr_lim4, pnr_alq4, pnr_lim5, pnr_alq5, pnr_lim6, pnr_alq6, pnr_lim7, pnr_alq7, pnr_alq8, | |
| eg_lim1, eg_alq1, eg_lim2, eg_alq2, eg_lim3, eg_alq3, eg_lim4, eg_alq4, eg_lim5, eg_alq5, eg_lim6, eg_alq6, eg_lim7, eg_alq7, eg_alq8, | |
| er_lim1, er_alq1, er_lim2, er_alq2, er_lim3, er_alq3, er_lim4, er_alq4, er_lim5, er_alq5, er_lim6, er_alq6, er_lim7, er_alq7, er_alq8, | |
| enr_lim1, enr_alq1, enr_lim2, enr_alq2, enr_lim3, enr_alq3, enr_lim4, enr_alq4, enr_lim5, enr_alq5, enr_lim6, enr_alq6, enr_lim7, enr_alq7, enr_alq8, | |
| t1df_lim1, t1df_alq1, t1df_alq2, | |
| t2df_lim1, t2df_alq1, t2df_alq2, | |
| t3df_lim1, t3df_alq1, t3df_alq2, | |
| tae_alq1, | |
| taf_alq1 | |
| ] | |
| excel_file_buffer = create_excel_download( | |
| df_resumo_iptu, result_agg, total_novo_str, total_atual_trib_str, total_atual_calc_str, | |
| valor_venal_choice, ufm_value_input, diferencia_estacionamentos_flag, diferencia_predios_flag, all_parameters | |
| ) | |
| # Calculate file size | |
| file_size_bytes = len(excel_file_buffer.getvalue()) | |
| if file_size_bytes < 1024 * 1024: # Less than 1MB | |
| size_str = f"{file_size_bytes / 1024:.1f} KB" | |
| else: | |
| size_str = f"{file_size_bytes / (1024 * 1024):.1f} MB" | |
| # Create timestamp in YYYYMMDD_HHMM format | |
| # Define the São Paulo timezone | |
| sao_paulo_tz = pytz.timezone("America/Sao_Paulo") | |
| now_sao_paulo = datetime.now(sao_paulo_tz) | |
| timestamp = now_sao_paulo.strftime("%Y%m%d_%H%M") | |
| filename = f"resultados_iptu_{timestamp}.xlsx" | |
| # Save to temporary file | |
| try: | |
| # First try the standard temp directory | |
| temp_dir = tempfile.gettempdir() | |
| temp_file_path = os.path.join(temp_dir, filename) | |
| with open(temp_file_path, 'wb') as f: | |
| f.write(excel_file_buffer.getvalue()) | |
| # Success - update UI components | |
| filename_text = filename | |
| download_button_result = gr.DownloadButton( | |
| label=f"Download ({size_str})", | |
| value=temp_file_path, | |
| visible=True | |
| ) | |
| except (PermissionError, OSError): | |
| # If that fails, try current directory (for HF Spaces) | |
| with open(filename, 'wb') as f: | |
| f.write(excel_file_buffer.getvalue()) | |
| # Success - update UI components | |
| filename_text = filename | |
| download_button_result = gr.DownloadButton( | |
| label=f"Download ({size_str})", | |
| value=filename, | |
| visible=True | |
| ) | |
| except Exception as e: | |
| print(f"Erro ao criar arquivo Excel: {str(e)}") | |
| filename_text = "" | |
| download_button_result = gr.DownloadButton(visible=False) | |
| return ("Processamento concluído.", df_resumo_iptu, result_agg, total_novo_str, total_atual_trib_str, total_atual_calc_str, | |
| gr.Textbox(value=filename_text, visible=bool(filename_text)), download_button_result) | |
| # Functions to handle field visibility | |
| def update_parking_visibility(diferencia_estacionamentos): | |
| """Update visibility of parking fields based on differentiation checkbox""" | |
| if diferencia_estacionamentos: | |
| # Hide EG, show ER and ENR | |
| return [ | |
| gr.Accordion(visible=False), # EG | |
| gr.Accordion(visible=True), # ER | |
| gr.Accordion(visible=True) # ENR | |
| ] | |
| else: | |
| # Show EG, hide ER and ENR | |
| return [ | |
| gr.Accordion(visible=True), # EG | |
| gr.Accordion(visible=False), # ER | |
| gr.Accordion(visible=False) # ENR | |
| ] | |
| def update_building_visibility(diferencia_predios): | |
| """Update visibility of building fields based on differentiation checkbox""" | |
| if diferencia_predios: | |
| # Hide PG, show PR and PNR | |
| return [ | |
| gr.Accordion(visible=False), # PG | |
| gr.Accordion(visible=True), # PR | |
| gr.Accordion(visible=True) # PNR | |
| ] | |
| else: | |
| # Show PG, hide PR and PNR | |
| return [ | |
| gr.Accordion(visible=True), # PG | |
| gr.Accordion(visible=False), # PR | |
| gr.Accordion(visible=False) # PNR | |
| ] | |
| # --- Gradio Interface --- | |
| with gr.Blocks(theme=gr.themes.Soft()) as demo: | |
| gr.Markdown("# Simulador de Cálculo de IPTU") | |
| gr.Markdown(f"Ajuste os parâmetros abaixo.") | |
| with gr.Row(): | |
| with gr.Column(scale=1): | |
| gr.Markdown("### Parâmetros Gerais") | |
| valor_venal_dropdown = gr.Dropdown(choices=["VV_90", "VV_85", "VV_80", "VV_90_RED", "VV_85_RED", "VV_80_RED"], value="VV_90", label="Valor Venal Utilizado") | |
| ufm_input = gr.Number(value=5.771, label="Valor da UFM (2025)") | |
| diferencia_estacionamentos_check = gr.Checkbox(value=False, label="Diferenciar Estacionamentos por Uso?") | |
| diferencia_predios_check = gr.Checkbox(value=False, label="Diferenciar Prédios por Uso?") | |
| # Import functionality | |
| gr.Markdown("### 📥 Importar Configurações") | |
| gr.Markdown("*Faça upload de um arquivo Excel gerado anteriormente para restaurar todas as configurações*") | |
| with gr.Group(): | |
| with gr.Row(): | |
| import_file = gr.File( | |
| label="Selecionar arquivo Excel", | |
| file_types=[".xlsx"], | |
| file_count="single", | |
| height=200 | |
| ) | |
| with gr.Row(): | |
| import_button = gr.Button("🔄 Importar Parâmetros", variant="secondary", size="lg", scale=2) | |
| clear_button = gr.Button("🗑️ Limpar", variant="outline", size="lg", scale=1) | |
| import_status = gr.Textbox( | |
| label="Status da Importação", | |
| interactive=False, | |
| visible=False, | |
| lines=2 | |
| ) | |
| gr.Markdown("### Faixas e Alíquotas Configuráveis") | |
| all_rate_inputs = [] | |
| pg_defaults_lim = [25000, 60000, 100000, 140000, 200000, 300000, 600000] | |
| pg_defaults_aliq = [0.0, 0.004, 0.0047, 0.0055, 0.0062, 0.007, 0.0077, 0.0085] | |
| # Create accordions with visibility control | |
| with gr.Accordion("Predial Geral (PG)", open=False, visible=True) as pg_accordion: | |
| pg_inputs = create_8_band_inputs("PG", pg_defaults_lim, pg_defaults_aliq) | |
| all_rate_inputs.extend(pg_inputs) | |
| with gr.Accordion("Predial Residencial (PR)", open=False, visible=False) as pr_accordion: | |
| pr_inputs = create_8_band_inputs("PR", pg_defaults_lim, pg_defaults_aliq) | |
| all_rate_inputs.extend(pr_inputs) | |
| with gr.Accordion("Predial Não Residencial (PNR)", open=False, visible=False) as pnr_accordion: | |
| pnr_inputs = create_8_band_inputs("PNR", pg_defaults_lim, pg_defaults_aliq) | |
| all_rate_inputs.extend(pnr_inputs) | |
| with gr.Accordion("Estacionamentos Geral (EG)", open=False, visible=True) as eg_accordion: | |
| eg_inputs = create_8_band_inputs("EG", pg_defaults_lim, pg_defaults_aliq) | |
| all_rate_inputs.extend(eg_inputs) | |
| with gr.Accordion("Estacionamentos Residenciais (ER)", open=False, visible=False) as er_accordion: | |
| er_inputs = create_8_band_inputs("ER", pg_defaults_lim, pg_defaults_aliq) | |
| all_rate_inputs.extend(er_inputs) | |
| with gr.Accordion("Estacionamentos Não Residenciais (ENR)", open=False, visible=False) as enr_accordion: | |
| enr_inputs = create_8_band_inputs("ENR", pg_defaults_lim, pg_defaults_aliq) | |
| all_rate_inputs.extend(enr_inputs) | |
| t_df_defaults_lim = 15000 | |
| with gr.Accordion("Terrenos 1a DF (T1DF)", open=False) as t1df_accordion: | |
| t1df_inputs = create_2_band_inputs("T1DF", t_df_defaults_lim, [0.0, 0.03]) | |
| all_rate_inputs.extend(t1df_inputs) | |
| with gr.Accordion("Terrenos 2a DF (T2DF)", open=False) as t2df_accordion: | |
| t2df_inputs = create_2_band_inputs("T2DF", t_df_defaults_lim, [0.0, 0.02]) | |
| all_rate_inputs.extend(t2df_inputs) | |
| with gr.Accordion("Terrenos 3a DF (T3DF)", open=False) as t3df_accordion: | |
| t3df_inputs = create_2_band_inputs("T3DF", t_df_defaults_lim, [0.0, 0.01]) | |
| all_rate_inputs.extend(t3df_inputs) | |
| # TAE and TAF are always hidden as requested | |
| with gr.Accordion("Terrenos Alíquota Especial (TAE)", open=False, visible=False) as tae_accordion: | |
| tae_alq1_input = gr.Number(label="TAE Alíquota 1 (ex: 0.009)", value=0.009) | |
| all_rate_inputs.append(tae_alq1_input) | |
| with gr.Accordion("Terrenos Alíquota Fixa (TAF)", open=False, visible=False) as taf_accordion: | |
| taf_alq1_input = gr.Number(label="TAF Alíquota 1 (ex: 0.0095)", value=0.0095) | |
| all_rate_inputs.append(taf_alq1_input) | |
| process_button = gr.Button("Processar Dados", variant="primary") | |
| with gr.Column(scale=2): | |
| status_message = gr.Textbox(label="Status", interactive=False) | |
| gr.Markdown("### Resumo Detalhado por Faixa e Categoria") | |
| output_df_resumo = gr.DataFrame(label="Resumo por Faixa", wrap=True) | |
| gr.Markdown("### Resumo Agregado por Categoria") | |
| output_df_result = gr.DataFrame(label="Resumo Agregado", wrap=True) | |
| gr.Markdown("### Totais Gerais Calculados") | |
| total_novo_text = gr.Textbox(interactive=False) | |
| total_atual_trib_text = gr.Textbox(interactive=False) | |
| total_atual_calc_text = gr.Textbox(interactive=False) | |
| # Add download section | |
| gr.Markdown("### Download Resultados") | |
| filename_display = gr.Textbox(label="Arquivo gerado", interactive=False, visible=False) | |
| download_btn = gr.DownloadButton(label="Download", visible=False) | |
| # Set up visibility change handlers | |
| diferencia_estacionamentos_check.change( | |
| fn=update_parking_visibility, | |
| inputs=[diferencia_estacionamentos_check], | |
| outputs=[eg_accordion, er_accordion, enr_accordion] | |
| ) | |
| diferencia_predios_check.change( | |
| fn=update_building_visibility, | |
| inputs=[diferencia_predios_check], | |
| outputs=[pg_accordion, pr_accordion, pnr_accordion] | |
| ) | |
| click_inputs = [ | |
| valor_venal_dropdown, ufm_input, | |
| diferencia_estacionamentos_check, diferencia_predios_check | |
| ] + all_rate_inputs | |
| # Import function with improved feedback | |
| def import_parameters(file_path): | |
| """Import parameters from Excel file with better feedback""" | |
| if not file_path: | |
| return [gr.update() for _ in range(len(all_rate_inputs) + 5)] # +5 for new status field | |
| try: | |
| # Read the parameters sheet | |
| df_params = pd.read_excel(file_path, sheet_name='Parâmetros Utilizados') | |
| # Extract general parameters | |
| valor_venal = df_params[df_params['Parâmetro'] == 'Valor Venal Utilizado']['Valor'].iloc[0] | |
| ufm_value = float(df_params[df_params['Parâmetro'] == 'Valor da UFM']['Valor'].iloc[0]) | |
| diferencia_est = df_params[df_params['Parâmetro'] == 'Diferenciar Estacionamentos por Uso']['Valor'].iloc[0] == 'Sim' | |
| diferencia_pred = df_params[df_params['Parâmetro'] == 'Diferenciar Prédios por Uso']['Valor'].iloc[0] == 'Sim' | |
| # Extract all parameter values in order | |
| param_patterns = [ | |
| # PG (15 params) | |
| ['PG Limite 1 (UFM)', 'PG Alíquota 1', 'PG Limite 2 (UFM)', 'PG Alíquota 2', 'PG Limite 3 (UFM)', 'PG Alíquota 3', | |
| 'PG Limite 4 (UFM)', 'PG Alíquota 4', 'PG Limite 5 (UFM)', 'PG Alíquota 5', 'PG Limite 6 (UFM)', 'PG Alíquota 6', | |
| 'PG Limite 7 (UFM)', 'PG Alíquota 7', 'PG Alíquota 8'], | |
| # PR (15 params) | |
| ['PR Limite 1 (UFM)', 'PR Alíquota 1', 'PR Limite 2 (UFM)', 'PR Alíquota 2', 'PR Limite 3 (UFM)', 'PR Alíquota 3', | |
| 'PR Limite 4 (UFM)', 'PR Alíquota 4', 'PR Limite 5 (UFM)', 'PR Alíquota 5', 'PR Limite 6 (UFM)', 'PR Alíquota 6', | |
| 'PR Limite 7 (UFM)', 'PR Alíquota 7', 'PR Alíquota 8'], | |
| # PNR (15 params) | |
| ['PNR Limite 1 (UFM)', 'PNR Alíquota 1', 'PNR Limite 2 (UFM)', 'PNR Alíquota 2', 'PNR Limite 3 (UFM)', 'PNR Alíquota 3', | |
| 'PNR Limite 4 (UFM)', 'PNR Alíquota 4', 'PNR Limite 5 (UFM)', 'PNR Alíquota 5', 'PNR Limite 6 (UFM)', 'PNR Alíquota 6', | |
| 'PNR Limite 7 (UFM)', 'PNR Alíquota 7', 'PNR Alíquota 8'], | |
| # EG (15 params) | |
| ['EG Limite 1 (UFM)', 'EG Alíquota 1', 'EG Limite 2 (UFM)', 'EG Alíquota 2', 'EG Limite 3 (UFM)', 'EG Alíquota 3', | |
| 'EG Limite 4 (UFM)', 'EG Alíquota 4', 'EG Limite 5 (UFM)', 'EG Alíquota 5', 'EG Limite 6 (UFM)', 'EG Alíquota 6', | |
| 'EG Limite 7 (UFM)', 'EG Alíquota 7', 'EG Alíquota 8'], | |
| # ER (15 params) | |
| ['ER Limite 1 (UFM)', 'ER Alíquota 1', 'ER Limite 2 (UFM)', 'ER Alíquota 2', 'ER Limite 3 (UFM)', 'ER Alíquota 3', | |
| 'ER Limite 4 (UFM)', 'ER Alíquota 4', 'ER Limite 5 (UFM)', 'ER Alíquota 5', 'ER Limite 6 (UFM)', 'ER Alíquota 6', | |
| 'ER Limite 7 (UFM)', 'ER Alíquota 7', 'ER Alíquota 8'], | |
| # ENR (15 params) | |
| ['EN Limite 1 (UFM)', 'EN Alíquota 1', 'EN Limite 2 (UFM)', 'EN Alíquota 2', 'EN Limite 3 (UFM)', 'EN Alíquota 3', | |
| 'EN Limite 4 (UFM)', 'EN Alíquota 4', 'EN Limite 5 (UFM)', 'EN Alíquota 5', 'EN Limite 6 (UFM)', 'EN Alíquota 6', | |
| 'EN Limite 7 (UFM)', 'EN Alíquota 7', 'EN Alíquota 8'], | |
| # T1DF (3 params) | |
| ['T1DF Limite 1 (UFM)', 'T1DF Alíquota 1', 'T1DF Alíquota 2'], | |
| # T2DF (3 params) | |
| ['T2DF Limite 1 (UFM)', 'T2DF Alíquota 1', 'T2DF Alíquota 2'], | |
| # T3DF (3 params) | |
| ['T3DF Limite 1 (UFM)', 'T3DF Alíquota 1', 'T3DF Alíquota 2'], | |
| # TAE (1 param) | |
| ['TAE Alíquota 1'], | |
| # TAF (1 param) | |
| ['TAF Alíquota 1'] | |
| ] | |
| # Flatten the patterns list | |
| all_param_names = [] | |
| for group in param_patterns: | |
| all_param_names.extend(group) | |
| # Extract values for each parameter | |
| param_values = [] | |
| missing_params = [] | |
| for param_name in all_param_names: | |
| try: | |
| value = df_params[df_params['Parâmetro'] == param_name]['Valor'].iloc[0] | |
| param_values.append(float(value) if pd.notnull(value) else 0.0) | |
| except (IndexError, ValueError): | |
| param_values.append(0.0) # Default value if not found | |
| missing_params.append(param_name) | |
| # Create success message | |
| if missing_params: | |
| status_msg = f"✅ Importação concluída com avisos!\n⚠️ {len(missing_params)} parâmetros não encontrados (valores padrão aplicados)" | |
| else: | |
| status_msg = f"✅ Importação concluída com sucesso!\n📊 {len(param_values)} parâmetros importados" | |
| # Return updates for all components | |
| updates = [ | |
| gr.update(value=valor_venal), # valor_venal_dropdown | |
| gr.update(value=ufm_value), # ufm_input | |
| gr.update(value=diferencia_est), # diferencia_estacionamentos_check | |
| gr.update(value=diferencia_pred), # diferencia_predios_check | |
| gr.update(value=status_msg, visible=True) # import_status | |
| ] | |
| # Add updates for all rate inputs | |
| for i, value in enumerate(param_values): | |
| if i < len(all_rate_inputs): | |
| updates.append(gr.update(value=value)) | |
| else: | |
| break | |
| # Pad with no-change updates if needed | |
| while len(updates) < len(all_rate_inputs) + 5: | |
| updates.append(gr.update()) | |
| return updates | |
| except Exception as e: | |
| error_msg = f"❌ Erro na importação:\n{str(e)}" | |
| updates = [ | |
| gr.update(), # valor_venal_dropdown - no change | |
| gr.update(), # ufm_input - no change | |
| gr.update(), # diferencia_estacionamentos_check - no change | |
| gr.update(), # diferencia_predios_check - no change | |
| gr.update(value=error_msg, visible=True) # import_status | |
| ] | |
| # Add no-change updates for all rate inputs | |
| updates.extend([gr.update() for _ in range(len(all_rate_inputs))]) | |
| return updates | |
| # Clear function | |
| def clear_all_parameters(): | |
| """Reset all parameters to default values""" | |
| pg_defaults_lim = [25000, 60000, 100000, 140000, 200000, 300000, 600000] | |
| pg_defaults_aliq = [0.0, 0.004, 0.0047, 0.0055, 0.0062, 0.007, 0.0077, 0.0085] | |
| t_df_defaults_lim = 15000 | |
| # Default values for all parameters | |
| default_values = [] | |
| # PG (15 params) | |
| for i in range(7): | |
| default_values.extend([pg_defaults_lim[i], pg_defaults_aliq[i]]) | |
| default_values.append(pg_defaults_aliq[7]) | |
| # PR (15 params) - same as PG | |
| for i in range(7): | |
| default_values.extend([pg_defaults_lim[i], pg_defaults_aliq[i]]) | |
| default_values.append(pg_defaults_aliq[7]) | |
| # PNR (15 params) - same as PG | |
| for i in range(7): | |
| default_values.extend([pg_defaults_lim[i], pg_defaults_aliq[i]]) | |
| default_values.append(pg_defaults_aliq[7]) | |
| # EG (15 params) - same as PG | |
| for i in range(7): | |
| default_values.extend([pg_defaults_lim[i], pg_defaults_aliq[i]]) | |
| default_values.append(pg_defaults_aliq[7]) | |
| # ER (15 params) - same as PG | |
| for i in range(7): | |
| default_values.extend([pg_defaults_lim[i], pg_defaults_aliq[i]]) | |
| default_values.append(pg_defaults_aliq[7]) | |
| # ENR (15 params) - same as PG | |
| for i in range(7): | |
| default_values.extend([pg_defaults_lim[i], pg_defaults_aliq[i]]) | |
| default_values.append(pg_defaults_aliq[7]) | |
| # T1DF (3 params) | |
| default_values.extend([t_df_defaults_lim, 0.0, 0.03]) | |
| # T2DF (3 params) | |
| default_values.extend([t_df_defaults_lim, 0.0, 0.02]) | |
| # T3DF (3 params) | |
| default_values.extend([t_df_defaults_lim, 0.0, 0.01]) | |
| # TAE (1 param) | |
| default_values.append(0.009) | |
| # TAF (1 param) | |
| default_values.append(0.0095) | |
| updates = [ | |
| gr.update(value="VV_90"), # valor_venal_dropdown | |
| gr.update(value=5.771), # ufm_input | |
| gr.update(value=False), # diferencia_estacionamentos_check | |
| gr.update(value=False), # diferencia_predios_check | |
| gr.update(value="🔄 Parâmetros resetados para valores padrão", visible=True) # import_status | |
| ] | |
| # Add updates for all rate inputs | |
| for i, value in enumerate(default_values): | |
| if i < len(all_rate_inputs): | |
| updates.append(gr.update(value=value)) | |
| else: | |
| break | |
| # Pad with no-change updates if needed | |
| while len(updates) < len(all_rate_inputs) + 5: | |
| updates.append(gr.update()) | |
| return updates | |
| # Set up import and clear button clicks | |
| import_button.click( | |
| fn=import_parameters, | |
| inputs=[import_file], | |
| outputs=[valor_venal_dropdown, ufm_input, diferencia_estacionamentos_check, diferencia_predios_check, import_status] + all_rate_inputs | |
| ) | |
| clear_button.click( | |
| fn=clear_all_parameters, | |
| inputs=[], | |
| outputs=[valor_venal_dropdown, ufm_input, diferencia_estacionamentos_check, diferencia_predios_check, import_status] + all_rate_inputs | |
| ) | |
| process_button.click( | |
| fn=process_iptu_data, | |
| inputs=click_inputs, | |
| outputs=[status_message, output_df_resumo, output_df_result, | |
| total_novo_text, total_atual_trib_text, total_atual_calc_text, filename_display, download_btn] | |
| ) | |
| gr.Markdown(f""" | |
| ## 📋 Instruções: | |
| ### 🎯 Fluxo Básico: | |
| 1. **⚙️ Parâmetros Gerais**: Configure valor venal, UFM e flags de diferenciação | |
| 2. **📊 Faixas e Alíquotas**: Ajuste limites (em UFM) e alíquotas (ex: 0.004 = 0.4%) | |
| 3. **▶️ Processar**: Clique em "Processar Dados" para calcular | |
| 4. **💾 Download**: Baixe os resultados completos em Excel | |
| ### 🔄 Import/Export de Configurações: | |
| - **📥 Importar**: Faça upload de arquivo Excel gerado anteriormente | |
| - **🗑️ Limpar**: Reset todos os parâmetros para valores padrão | |
| ### 📊 Conteúdo do Excel: | |
| - **📈 Resumo Detalhado**: Dados por faixa e categoria | |
| - **📋 Resumo Agregado**: Totais por categoria principal | |
| - **💰 Totais Gerais**: Sumário dos valores calculados | |
| - **⚙️ Parâmetros Utilizados**: Configurações completas (reimportáveis) | |
| ### 🎛️ Controles de Visibilidade: | |
| - **Estacionamentos**: Marque "Diferenciar por Uso" para mostrar campos ER/ENR em vez de EG | |
| - **Prédios**: Marque "Diferenciar por Uso" para mostrar campos PR/PNR em vez de PG | |
| - **TAE/TAF**: Campos sempre ocultos (configurados internamente) | |
| """) | |
| if __name__ == "__main__": | |
| demo.launch() |