app.py

import gradio as gr
import pandas as pd
import geopandas as gpd
from gradio.components import Number, Textbox, Dropdown, Button
from gradio import Interface
import pyproj
import plotly.express as px
import plotly.graph_objects as go
import plotly.io as pio
from docx import Document
from docx.shared import Pt
from docx.enum.text import WD_PARAGRAPH_ALIGNMENT
from docx.shared import Inches
from docx.oxml.ns import qn
from docx.oxml import OxmlElement
from docx.shared import RGBColor
from fpdf import FPDF
import datetime
import os
import numpy as np

# Carrega o .csv com a base de valores de face
df = pd.read_csv('BD_eqv.csv', sep=';', encoding='latin-1')

# Carrega o .csv com a base de valores de face
df_rh = pd.read_csv('rh.csv', sep=';', encoding='latin-1')

# Carrega o .csv com a base de valores de face
df_2 = pd.read_excel('Planilha_histórico_IT.xlsx')

# Função para converte as coordenadas sirgas em wgs

def plota(df):
    # Define the TM-POA projection
    tm_poa = pyproj.Proj("+proj=tmerc +lat_0=0 +lon_0=-51 +k_0=0.999995 +x_0=300000 +y_0=5000000 +ellps=GRS80 +units=m +no_defs")

    # Define the WGS84 projection
    wgs84 = pyproj.Proj("+proj=longlat +ellps=WGS84 +datum=WGS84 +no_defs")

    # Convert the SIRGAS2000 coordinates to latitude and longitude
    lon, lat = pyproj.transform(tm_poa, wgs84, df['X'].values, df['Y'].values)

    # Calculate bounding box
    min_lon, max_lon = lon.min(), lon.max()
    min_lat, max_lat = lat.min(), lat.max()

    # Create a Plotly Scattermapbox
    fig = go.Figure(go.Scattermapbox(
        lat=lat,
        lon=lon,
        mode='markers',
        marker=dict(size=15, color=['green','orange']),
        text=df[['LOGRAD', 'NUM']]
    ))


    # Set the mapbox style
    fig.update_layout(mapbox_style='carto-positron')

    # Set the center and zoom of the map based on bounding box
    center_lon = (min_lon + max_lon) / 2
    center_lat = (min_lat + max_lat) / 2
    zoom = 10  # You can adjust the zoom level as needed

    fig.update_layout(mapbox=dict(center=dict(lon=center_lon, lat=center_lat), zoom=10))

    # Show the map
    fig.show()

    return fig


# ---------------------------------------Função para calcular a equivalência-----------------------------------------------------#

def calculate_equivalent(manual, manual_RH_O, manual_RH_D, requer, docs, it, processo, prop_o, log_origem, num_origem, tipo_o, doc_o, zona_o, prop_d, log_destino,
                         num_destino, tipo_d, doc_d, zona_d, incluir):

                             try:


# ----------------------------------------------PESQUISA-------------------------------------------------------#

                                if manual == "Manual":
                                    # Para fazer a pesquisa de forma manual pelo RH
                                    pesquisa_O = df_rh[df_rh['RH'] == manual_RH_O]
                                    pesquisa_D = df_rh[df_rh['RH'] == manual_RH_D]

                                # Verifica se há resultados nas pesquisas
                                    if not pesquisa_O.empty and not pesquisa_D.empty:
                                        VU_O = float(pesquisa_O['VU'].iloc[0].replace('.', '').replace(',', '.'))
                                        VU_D = float(pesquisa_D['VU'].iloc[0].replace('.', '').replace(',', '.'))

                                        RH_O = manual_RH_O
                                        RH_D = manual_RH_D

                                else:
                                    # Para fazer a pesquisa de forma automática pelo endereço
                                    pesquisa_O = df[(df['LOGRAD'] == log_origem) & (df['NUM'] == num_origem)]
                                    pesquisa_D = df[(df['LOGRAD'] == log_destino) & (df['NUM'] == num_destino)]

                                    # Verifica se há resultados nas pesquisas
                                    if not pesquisa_O.empty and not pesquisa_D.empty:
                                        VU_O = float(pesquisa_O['VU'].iloc[0].replace('.', '').replace(',', '.'))
                                        VU_D = float(pesquisa_D['VU'].iloc[0].replace('.', '').replace(',', '.'))

                                        RH_O = pesquisa_O['RH'].iloc[0]
                                        RH_D = pesquisa_D['RH'].iloc[0]


                                mapa_O = df[(df['LOGRAD'] == log_origem) & (df['NUM'] == num_origem)]
                                mapa_D = df[(df['LOGRAD'] == log_destino) & (df['NUM'] == num_destino)]
                                df_combined = pd.concat([mapa_O, mapa_D], ignore_index=True)
                                distance_euclidean = round(np.sqrt((df_combined['X'].max() - df_combined['X'].min())**2 + (df_combined['Y'].max() - df_combined['Y'].min())**2), 0)

# --------------------------------------------CÁLCULO---------------------------------------------------------#

                                # Se ambos os valores foram encontrados, realize a divisão
                                eqv = round(VU_O / VU_D, 4)

# ------------------------------------------ IMPRIMIR DOCUMENTAÇÃO ------------------------------------------ #

                                # Separa os itens da lista
                                formatted_docs = ', '.join(docs)
                             
# --------------------------------------------STRINGS---------------------------------------------------------#

                                documentação = f"""
                                Requerente: {requer}
                                Documentação: {formatted_docs}
                                """
                                ano_corrente = datetime.datetime.now().year
                                título = f"""
                                INFORMAÇÃO TÉCNICA
                                EQUIVALÊNCIA PARA ÍNDICE CONSTRUTIVO
                                IT_{it}_{ano_corrente}_EQUIV
                                """
                                introdução = f"""
                                Conforme solicitação formulada através do processo n.º {processo}, estamos informando a equivalência de valores para a transferência de índices construtivos, tendo por base valores territoriais.O Coeficiente de Equivalência foi calculado com base na documentação apresentada no processo, e possui validade de 1(um) ano, a partir da data de sua emissão. Deverá ser verificada, junto à Secretaria competente, a viabilidade da transferência de índices solicitada.
                                """
                                resultados = f"""
                                ORIGEM
                                Proprietário origem: {prop_o}
                                Endereço: {log_origem}
                                Número: {int(num_origem)}
                                RH: {RH_O}
                                Valor unitário: R$ {VU_O:,.2f} /m²
                                Tipo: {tipo_o}
                                Documento: {doc_o}
                                Zona: {zona_o}
                                DESTINO
                                Proprietário origem: {prop_d}
                                Endereço: {log_destino}
                                Número: {int(num_destino)}
                                RH: {RH_D}
                                Valor unitário DESTINO: R$ {VU_D:,.2f} /m²
                                Tipo: {tipo_d}
                                Documento: {doc_d}
                                Zona: {zona_d}
                                EQUIVALÊNCIA de ÍNDICE: {eqv}
                                """
                                  # Substituindo ponto por vírgula
                                resultados = resultados.replace('.', '@')
                                resultados = resultados.replace(',', '.')
                                resultados = resultados.replace('@', ',')

                                #Distância: {distance_euclidean}

#---------------------------------------------------RELATÓRIO NO WORD-----------------------------------------------#

                                # Criação de um relatório da avaliação no word
                                # Criar um novo documento do Word
                                doc = Document()

                                # Definir o título do documento
                                doc.add_heading('', level=1)

                                # Definir as seções do relatório
                                sections = [
                                    (documentação, ""),
                                    (título, " "),
                                    (introdução, "  "),
                                    (resultados, ""),
                                ]

                                for content, title in sections:
                                    doc.add_heading(title, level=2)
                                    p = doc.add_paragraph()
                                    run = p.add_run(str(content))
                                    run.font.name = 'Arial'
                                    run.font.size = Pt(10)
                                    p.alignment = WD_PARAGRAPH_ALIGNMENT.LEFT  # Define o alinhamento para à esquerda


                                    # Adiciona alinhamento à direita para a assinatura
                                    if title == "  ":
                                        run.font.size = Pt(10)
                                        run.font.name = 'Arial'
                                        p.alignment = WD_PARAGRAPH_ALIGNMENT.JUSTIFY

                                    # Adiciona alinhamento à direita para a assinatura
                                    if title == " ":
                                        run.font.size = Pt(14)
                                        run.font.name = 'Arial'
                                        run.bold = True
                                        p.alignment = WD_PARAGRAPH_ALIGNMENT.CENTER

                                    # Configuração do espaço antes e depois dos parágrafos
                                for paragraph in doc.paragraphs:
                                    if paragraph.style.name.startswith('Heading'):
                                        paragraph.space_before = Pt(0)  # Elimina espaço antes dos títulos
                                    else:
                                        paragraph.space_before = Pt(0)  # Espaço antes do parágrafo (ajuste conforme necessário)
                                    paragraph.space_after = Pt(0)   # Espaço depois do parágrafo (ajuste conforme necessário)

                                # Salvar o documento em um arquivo .doc
                                doc.save('Informação Técnica.doc')

#--------------------------------------------------RELATÓRIO EM PDF------------------------------------------------#

                                # Abre o documento do Word
                                docx_file = "Informação Técnica.doc"
                                doc = Document(docx_file)

                                # Cria um novo arquivo PDF
                                pdf = FPDF()
                                pdf.add_page()

                                # Define a fonte para Arial e o tamanho da fonte
                                pdf.set_font("Arial", size=12)

                                # Itera sobre os parágrafos do documento do Word e adiciona ao PDF
                                for paragraph in doc.paragraphs:
                                    pdf.multi_cell(0, 5, paragraph.text)
                                    pdf.ln()

                                # Salva o arquivo PDF
                                pdf_file = "Informação_Técnica.pdf"
                                pdf.output(pdf_file)

#-----------------------------------------------------DATAFRAME-----------------------------------------------------#

                                #Cria um DataFrame com os resultados
                                results_df = pd.DataFrame({
                                            'Processo': [processo],
                                            'Requerente': [requer],
                                            'Documentos': [docs],
                                            'Proprietário origem': [prop_o],
                                            'Endereço origem': [log_origem],
                                            'Número origem': [int(num_origem)],
                                            'RH origem': [RH_O],
                                            'Valor unitário origem (R$/m²)': [VU_O],
                                            'Tipo origem': [tipo_o],
                                            'Documento origem': [doc_o],
                                            'Zona origem': [zona_o],
                                            'Proprietário destino': [prop_d],
                                            'Endereço destino': [log_destino],
                                            'Número destino': [int(num_destino)],
                                            'RH destino': [RH_D],
                                            'Valor unitário destino (R$/m²)': [VU_D],
                                            'Tipo destino': [tipo_d],
                                            'Documento destino': [doc_d],
                                            'Zona destino': [zona_d],
                                            'Equivalência de Índice': [eqv],
                                            'IT': [f'IT_{it}_{datetime.datetime.now().year}_EQUIV']
                                        })

                                # Salva o DataFrame em um arquivo Excel
                                # excel_file = 'Planilha_histórico_IT.xlsx'
                                # results_df.to_excel(excel_file, index=False)

                                # Verifica se o arquivo já existe
                                if os.path.exists('Planilha_histórico_IT.xlsx'):
                                    existing_df = pd.read_excel('Planilha_histórico_IT.xlsx')
                                    updated_df = pd.concat([existing_df, results_df], ignore_index=True)
                                    if incluir == "Sim":
                                      pdated_df.to_excel('Planilha_histórico_IT.xlsx', index=False)
                                else:
                                    results_df.to_excel('Planilha_histórico_IT.xlsx', index=False)


#---------------------------------------------------------MAPA---------------------------------------------------------#

                                mapa = plota(df_combined)

#-------------------------------------------------------OUTPUTS--------------------------------------------------------#

                                return documentação, título, introdução, resultados, mapa, pdf_file, 'Planilha_histórico_IT.xlsx'   #, 'Informação Técnica.doc'

#-------------------------------------------------------EXCEPTION-------------------------------------------------------#

                             except Exception as e:
                                 # Here, you handle any errors that occur in your function.
                                 # You can log the actual error to console or a file if needed for debugging.
                                 print(f"Error: {e}")

                                 # Return a custom error message to the user
                                 custom_error_message = "Revisar as informações fornecidas"
                                 # Return this message in the same format as your function's successful output
                                 return None, None, None, custom_error_message, None, None, None

#------------------------------------------------------INTERFACE-------------------------------------------------------#

# Obtenha a lista única de logradouros do DataFrame
df_log = df[['LOGRAD']]
df_log = df_log.drop_duplicates()
logs = df_log['LOGRAD'].tolist()

iface = gr.Interface(
    fn=calculate_equivalent,
    inputs=[

        gr.Radio(["Automático", "Manual"], label="Caso você queira fazer a entrada de foma manual utilizando o RH, marque a opção Manual",value="Automático"),
        gr.Slider(minimum=1, maximum=380, value=1, label="RH da origem"),
        gr.Slider(minimum=1, maximum=380, value=1, label="RH do destino"),

        gr.Text(label="Requerente"),
        gr.Dropdown(["Proprietário", "Procurador", "Origem","Destino"], multiselect=True, label="Documentação apresentada"),

        gr.Text(label="Número da IT"),
        gr.Text(label="Processo", value="00.0.000000000-0"),

        gr.Text(label="Proprietário origem"),
        gr.Dropdown(logs, label="Logradouro de origem", value ='Rua GEN JOAO MANOEL'),
        gr.Number(minimum=1, label="Número de origem", value =157),
        gr.Dropdown(["Matrícula", "Certidão", "Escritura Pública", "outro"], label="Tipo de documento", value ='Matrícula',
                   info="Escolha o tipo de documento"),
        gr.Number(label="Número do Documento"),
        gr.Dropdown(["1ª", "2ª", "3ª", "4ª", "5ª", "6ª"], label="Zona", value ='-',
                   info="Escolha a zona"),

        gr.Text(label="Proprietário destino"),
        gr.Dropdown(logs, label="Logradouro de destino", value ='Rua URUGUAI'),
        gr.Number(minimum=1, label="Número de destino", value =277),
        gr.Dropdown(["Matrícula", "Certidão", "Escritura Pública", "outro"], label="Tipo de documento", value ='Matrícula',
                   info="Escolha o tipo de documento"),
        gr.Number(label="Número do Documento"),
        gr.Dropdown(["1ª", "2ª", "3ª", "4ª", "5ª", "6ª"], label="Zona", value ='-',
                   info="Escolha a zona"),
        gr.Radio(["Sim", "Não"], label="Incluir a IT no histórico",value="Não"),
    ],
    outputs=[
        gr.Textbox(label="Documentação apresentada"),
        gr.Textbox(label="Título"),
        gr.Textbox(label="EQUIVALÊNCIA PARA ÍNDICE CONSTRUTIVO"),
        gr.Textbox(label="Resultados"),
        gr.Plot(label="Localização do Imóvel de Origem e de Destino"),
        #gr.File(label="Informação Técnica - arquivo word"),
        gr.File(label="Informação Técnica - arquivo PDF"),
        gr.File(label="Histórico das IT's - arquivo Excel"),
    ]
)

iface.launch(debug=True)