infrapy 0.1.0__py3-none-any.whl

infrapy/__init__.py

@@ -0,0 +1,12 @@
+# src/infrapy/__init__.py
+
+from . import config
+from . import cores
+from . import excel
+from . import export
+from . import geo
+from . import mapas
+from . import sharepoint
+from . import interface
+
+__version__ = "0.1.0"

infrapy/config.py

@@ -0,0 +1,131 @@
+"""
+config.py - ponto unico onde o pacote le configuracao/segredos do ambiente.
+
+Nenhuma credencial ou caminho pessoal fica escrito aqui. Tudo vem do .env
+(carregado no __init__.py). Estruturas compostas (ex.: o dicionario de
+credenciais do certificado) sao MONTADAS aqui a partir das variaveis
+simples lidas do .env.
+"""
+
+if True: # Bibliotecas
+    import os
+
+
+if True: # Funcoes que leem o .env
+    def _get(nome, obrigatorio=True, default=None) -> str | None:
+        """
+        Le uma variavel de ambiente (vinda do .env).
+        
+        Parameters
+        ----------
+        nome : str
+            Nome da variavel no .env.
+        obrigatorio : bool, optional
+            Se True, levanta erro quando a variavel esta ausente. Padrao True.
+        default : str, optional
+            Valor retornado quando a variavel nao existe e nao e obrigatoria.
+        
+        Returns
+        -------
+        str or None
+            Valor da variavel, ou o default.
+        
+        Raises
+        ------
+        RuntimeError
+            Se a variavel for obrigatoria e nao estiver definida.
+        """
+        valor = os.environ.get(nome, default)
+        if obrigatorio and not valor:
+            raise RuntimeError(
+                f"[infrapy] variavel '{nome}' nao encontrada. "
+                f"Adicione-a ao seu .env. Veja .env.example."
+            )
+        return valor
+    
+    # ---- Caminhos padrao ----
+    def PATH_ACC() -> str | None:
+        """Caminho base do projeto ACC. Retorna str ou None."""
+        return _get("ACC_PATH", obrigatorio=False)
+    
+    def PATH_SHAREPOINT() -> str | None:
+        """Caminho local ate a pasta do SharePoint. Retorna str ou None."""
+        return _get("SHAREPOINT_PATH", obrigatorio=False)
+    
+    def PATH_REDE() -> str | None:
+        """Caminho de rede padrao do projeto na Infra. Retorna str ou None."""
+        return _get("REDE_PATH", obrigatorio=False)
+    
+    def PATH_BASE_ALN() -> str | None:
+        """Caminho padrão da base de alinhamentos. Retorna str ou None."""
+        return _get("BASE_ALINHAMENTOS", obrigatorio=False)
+    
+    # ---- SharePoint ----
+    def SHAREPOINT_USER() -> str:
+        """E-mail/usuario do SharePoint. Retorna str."""
+        return _get("INFRA_USER")
+    
+    def SHAREPOINT_PASSWORD() -> str:
+        """Senha do SharePoint. Retorna str."""
+        return _get("INFRA_SENHA")
+    
+    def SHAREPOINT_SITE() -> str:
+        """URL do site do SharePoint. Retorna str."""
+        return _get("INFRA_SITE")
+    
+    def SHAREPOINT_URL() -> str:
+        """URL relativa base dos documentos no SharePoint. Retorna str."""
+        return _get("INFRA_URL", obrigatorio=False)
+    
+    # ---- Azure / certificado ---- APENAS TI PODE GERAR/FORNECER
+    def SHAREPOINT_TENANT_ID() -> str:
+        """ID do Tenant(SITE) do sharepoint. Retorna str."""
+        return _get("INFRA_AZURE_TENANT_ID", obrigatorio=False)
+    
+    def SHAREPOINT_CLIENT_ID() -> str:
+        """ID da aplicação do Azure. Retorna str."""
+        return _get("INFRA_AZURE_CLIENT_ID", obrigatorio=False)
+    
+    def SHAREPOINT_CERTIFICATE_THUMBPRINT() -> str:
+        """Certificado da aplicação do Azure. Retorna str."""
+        return _get("CERT_THUMBPRINT", obrigatorio=False)
+    
+    def SHAREPOINT_CERTIFICATE_KEY() -> str:
+        """Caminho da "key.pem" do Azure. Retorna str."""
+        return _get("CERT_KEY", obrigatorio=False)
+    
+    def SHAREPOINT_CERTIFICATE() -> dict:
+        """
+        Monta o dicionario de credenciais de app do Azure (autenticacao por
+        certificado), a partir das variaveis simples do .env.
+        
+        Returns
+        -------
+        dict
+            Dicionario com as chaves tenant, client_id, thumbprint e cert_path,
+            no formato esperado pelo Office365-REST-Python-Client.
+        """
+        return {
+            "tenant": _get("INFRA_AZURE_TENANT_ID"),
+            "client_id": _get("INFRA_AZURE_CLIENT_ID"),
+            "thumbprint": _get("CERT_THUMBPRINT"),
+            "cert_path": _get("CERT_KEY"),
+        }
+    
+    # ---- DBeaver / PostgreSQL ----
+    def DBEAVER_CONFIG() -> dict:
+        """
+        Retorna as credenciais de conexao ao banco (DBeaver/PostgreSQL).
+        
+        Returns
+        -------
+        dict
+            Dicionario com user, password, host, port e database.
+        """
+        return {
+            "user": _get("DBEAVER_USER"),
+            "password": _get("DBEAVER_PASSWORD"),
+            "host": _get("DBEAVER_HOST"),
+            "port": _get("DBEAVER_PORT"),
+            "database": _get("DBEAVER_DATABASE"),
+        }

infrapy/cores.py

@@ -0,0 +1,120 @@
+"""cores.py - geracao de cores aleatorias e exibicao no Jupyter."""
+
+if True: # Bibliotecas
+    from IPython.display import HTML, display
+    from typing import Iterable
+    import random
+
+if True: # Funcoes
+    def cor_aleatoria() -> str:
+        """
+        Gera uma cor hexadecimal aleatória.
+        
+        A cor é gerada sorteando um valor inteiro entre ``0x000000`` e
+        ``0xFFFFFF`` e convertendo-o para o formato hexadecimal utilizado em CSS.
+        
+        Returns
+        -------
+        str
+            Código hexadecimal da cor no formato ``"#RRGGBB"``.
+            
+        Examples
+        --------
+        >>> cor_aleatoria()
+        '#3fa9d2'
+        """
+        return f"#{random.randint(0, 0xFFFFFF):06x}"
+    
+    def cor_aleatoria_variada() -> str:
+        """
+        Gera uma cor hexadecimal aleatória com maior saturação.
+        
+        A função limita um dos canais RGB a zero e sorteia os outros dois
+        entre 60 e 255, produzindo predominantemente cores mais vibrantes
+        e evitando tons muito escuros ou acinzentados.
+        
+        Returns
+        -------
+        str
+            Código hexadecimal da cor no formato ``"#RRGGBB"``.
+        
+        Examples
+        --------
+        >>> cor_aleatoria_variada()
+        '#ff7a00'
+        """
+        valores_1 = [(60, 255), (0, 0), (60, 255)]
+        valores_2 = [(0, 0), (60, 255), (60, 255)]
+        valores_3 = [(60, 255), (60, 255), (0, 0)]
+        
+        valores = random.choice([valores_1, valores_2, valores_3])
+        
+        R = random.randint(valores[0][0], valores[0][1])
+        G = random.randint(valores[1][0], valores[1][1])
+        B = random.randint(valores[2][0], valores[2][1])
+        
+        return f"#{R:02x}{G:02x}{B:02x}"
+    
+    def cor_aleatoria_predef() -> str:
+        """
+        Retorna uma cor escolhida aleatoriamente de uma paleta predefinida.
+        
+        A paleta contém cores previamente selecionadas, incluindo tons de
+        azul, roxo, ciano, magenta, vermelho, amarelo, verde e cores neutras.
+        
+        Returns
+        -------
+        str
+            Código hexadecimal da cor selecionada no formato ``"#RRGGBB"``.
+        
+        Examples
+        --------
+        >>> cor_aleatoria_predef()
+        '#1f7ee6'
+        """
+        cores_predefinidas = [
+            # Tons de azul e roxo
+            "#500090", "#3e23b4", "#cb99e1", "#1f7ee6", "#005987", "#55aaff",
+            # Tons de ciano
+            "#00ffff", "#00b7c7",
+            # Tons de magenta
+            "#ff00ff", "#ff007f", "#a300a5", "#9600f4", "#aa007f", "#860044", "#ffaaff",
+            # Tons de vermelho
+            "#ff0000", "#f94305", "#ad2a0d", "#dd4160", "#ff8ba5", "#ffaa7f",
+            # Tons de amarelo
+            "#ffff00", "#afdb00", "#deec00", "#c5c800", "#c6b200", "#bd9033",
+            # Tons de verde
+            "#00ff00", "#00ff7f", "#47c700", "#01ed9d", "#00f63d",
+            # Tons neutros
+            "#ffffff", "#b4f3db", "#add3b1", "#d2af9f", "#979768", "#1a2b35"
+        ]
+        return random.choice(cores_predefinidas)
+    
+    def exibir_blocos_cores_ipynb(cores: Iterable[str]) -> None:
+        """
+        Exibe uma paleta de cores em um notebook Jupyter.
+        
+        Cria um conjunto de retângulos coloridos utilizando HTML, onde cada
+        retângulo possui a cor especificada e exibe seu respectivo nome ou
+        código hexadecimal.
+        
+        Parameters
+        ----------
+        cores : Iterable[str]
+            Iterável contendo nomes de cores CSS ou códigos de cores
+            (ex.: "#FF0000", "red", "rgb(0, 128, 255)", (f"#{i:06X}" for i in range(10)) ).
+            
+        Returns
+        -------
+        None
+            A função apenas renderiza o HTML no notebook.
+        
+        Examples
+        --------
+        >>> exibir_blocos_cores_ipynb(["#FF0000", "#00FF00", "#0000FF", "gold", "royalblue"])
+        """
+        html = "<div style='display: flex; flex-wrap: wrap;'>"
+        for cor in cores:
+            html += f"<div style='width: 100px; height: 50px; background-color: {cor}; margin: 5px; text-align: center; line-height: 50px; color: #fff;'>{cor}</div>"
+        html += "</div>"
+        display(HTML(html))

infrapy/excel.py

@@ -0,0 +1,147 @@
+"""excel.py - leitura de planilhas (xlwings) e exportacao para xlsx."""
+
+if True: # Bibliotecas
+    import os
+    import pandas as pd
+    import geopandas as gpd
+    import xlwings as xw
+    
+    from . import config
+
+if True: # Funcoes
+    
+    def abrir_ou_conectar_excel(caminho: str) -> xw.Book:
+        """
+        Retorna um objeto Book do xlwings, reaproveitando o arquivo se ele ja
+        estiver aberto no Excel, ou abrindo-o do disco caso contrario.
+        
+        Parameters
+        ----------
+        caminho : str
+            Caminho completo do arquivo .xlsx/.xlsb a abrir.
+        
+        Returns
+        -------
+        xlwings.Book
+            O livro correspondente ao arquivo, ja aberto e pronto para uso.
+        
+        Raises
+        ------
+        FileNotFoundError
+            Se o arquivo nao existir no disco e tambem nao estiver aberto.
+        
+        """
+        nome_alvo = os.path.basename(caminho).lower()
+        
+        for app in xw.apps:
+            for livro in app.books:
+                if livro.name.lower() == nome_alvo:
+                    return livro
+                
+        if not os.path.exists(caminho):
+            raise FileNotFoundError(
+                f"Arquivo nao encontrado e nao esta aberto no Excel: {caminho}"
+            )
+            
+        return xw.Book(caminho)
+    
+    def ler_excel(caminho: str, aba: str | int, celula: str, CRS: str | None = None, expandir: bool = True) -> tuple[xw.Sheet, pd.DataFrame | gpd.GeoDataFrame]:
+        """
+        Le uma tabela de um arquivo Excel via xlwings.
+        
+        Reaproveita o arquivo se ele ja estiver aberto no Excel, evitando conflitos de instancia.
+        
+        Parameters
+        ----------
+        caminho : str
+            Caminho completo do arquivo Excel.
+        
+        aba : str or int
+            Nome ou indice da planilha (aba).
+        
+        celula : str
+            Ponto de leitura. Se ``expandir=True``, e a celula ancora onde a
+            tabela comeca (ex.: "A1"). Se ``expandir=False``, e o intervalo
+            exato a ler (ex.: "A1:F20").
+        
+        CRS : str, optional
+            Se informado (ex.: "EPSG:4326"), retorna um GeoDataFrame, criando a
+            coluna 'geometry' vazia se ela nao existir. Padrao None (DataFrame).
+        
+        expandir : bool, optional
+        Se True (padrao), expande a partir da celula ancora para toda a
+        regiao de dados contigua. Se False, le exatamente o intervalo
+        informado em ``celula``.
+        
+        Returns
+        -------
+        tuple of (xlwings.Sheet, pandas.DataFrame or geopandas.GeoDataFrame)
+            A planilha (para manipulacao posterior) e os dados lidos. O segundo
+            elemento e um GeoDataFrame quando ``CRS`` e informado, senao um
+            DataFrame comum.
+        
+        Examples
+        --------
+        Expandir a partir de uma celula ancora (comportamento padrao):
+        
+        >>> ws, df = ler_excel("dados.xlsx", "Plan1", "A1")
+        
+        Ler um intervalo exato, sem expandir:
+        
+        >>> ws, df = ler_excel("dados.xlsx", "Plan1", "A1:F20", expandir=False)
+        
+        Ler como dado geografico:
+        
+        >>> ws, gdf = ler_excel("snv.xlsx", "SNV", "A1", CRS="EPSG:4326")
+        """
+        wb = abrir_ou_conectar_excel(caminho)
+        ws = wb.sheets(aba)
+        
+        rng = ws.range(celula)
+        if expandir:
+            rng = rng.expand(mode='table')
+        
+        df = rng.options(pd.DataFrame, index=False, header=1).value
+        
+        if CRS is not None:
+            if 'geometry' not in df.columns:
+                df['geometry'] = None
+            df = gpd.GeoDataFrame(df, crs=CRS, geometry='geometry')
+        
+        return ws, df
+    
+    def exportar_abas(caminho: str, abas: list[str], output: str) -> None:
+        """
+        Le abas especificas de um arquivo Excel e salva cada uma como um .xlsx
+        separado na pasta de saida.
+        
+        Parameters
+        ----------
+        caminho : str
+            Caminho do arquivo Excel de origem.
+        
+        abas : list of str
+            Nomes das abas a exportar.
+        
+        output : str
+            Pasta de destino. Criada automaticamente se nao existir.
+        
+        Returns
+        -------
+        None
+        
+        Examples
+        --------
+        >>> exportar_abas("origem.xlsx", ["Jan", "Fev"], "saida/")
+        """
+        if not os.path.exists(output):
+            os.makedirs(output)
+        
+        for aba in abas:
+            df = pd.read_excel(caminho, sheet_name=aba)
+            df.dropna(subset=["COD"], inplace=True)
+            nome_arquivo = os.path.join(output, f"{aba}.xlsx")
+            if os.path.exists(nome_arquivo):
+                os.remove(nome_arquivo)
+            with pd.ExcelWriter(nome_arquivo, engine='xlsxwriter') as writer:
+                df.to_excel(writer, sheet_name=aba, index=False)

infrapy/export.py

@@ -0,0 +1,42 @@
+"""export.py - exportacao de DataFrames/GeoDataFrames para xlsx e shapefile."""
+
+if True: # Bibliotecas
+    import os
+    import json
+    
+    import geopandas as gpd
+    from shapely.geometry import shape
+    
+    from . import config
+
+if True: # Funcoes
+    
+    def JSON_para_SHP(caminho: str, arquivo: str) -> None:
+        """
+        Le um GeoJSON e salva como shapefile na mesma pasta.
+        
+        Parameters
+        ----------
+        caminho : str
+            Pasta onde esta o arquivo .json (e onde o .shp sera salvo).
+        arquivo : str
+            Nome do arquivo (sem extensao).
+            
+        Returns
+        -------
+        None
+        
+        Examples
+        --------
+        >>> JSON_para_SHP("dados/", "vetores")
+        """
+        # Load the JSON file
+        with open(fr'{caminho}/{arquivo}.json') as f:
+            data = json.load(f)
+            
+        # Convert the JSON data to a GeoDataFrame
+        geoms = [shape(item['geometry']) for item in data['features']]
+        gdf = gpd.GeoDataFrame(data['features'], geometry=geoms, crs="EPSG:4326")
+        
+        # Save the GeoDataFrame as a shapefile
+        gdf.to_file(fr'{caminho}/{arquivo}')

infrapy/geo.py

@@ -0,0 +1,569 @@
+"""geo.py - geoprocessamento: leitura de shapes, conversao de coordenadas,
+calculo de km em alinhamentos/SNV, cortes e utilitarios geometricos."""
+
+if True: # Bibliotecas
+    from typing import Tuple
+    
+    import math
+    import warnings
+    
+    import geopandas as gpd
+    import pandas as pd
+    
+    import shapely
+    from shapely import ops
+    from shapely.ops import substring
+    from shapely.geometry import Point, LineString
+    import shapely.geometry as geom
+    from shapely.errors import ShapelyDeprecationWarning
+    
+    import re
+    
+    from . import config
+
+if True: # Funcoes
+    
+    # ------ Auxiliares -----
+    def closest_geometry(gdf: gpd.GeoDataFrame, point: shapely.geometry.point.Point | tuple) -> str:
+        """
+        Retorna a geometria mais próxima de um ponto.
+        
+        Parameters
+        ----------
+        gdf : geopandas.GeoDataFrame
+            GeoDataFrame contendo uma coluna de geometria.
+        point : shapely.geometry.point.Point | tuple[float, float]
+            Ponto de referência ou tupla (x, y).
+        
+        Returns
+        -------
+        tuple[int, BaseGeometry, float]
+            Índice da geometria, geometria encontrada e distância.
+        
+        Raises
+        ------
+        RuntimeError
+            Se o geodataframe utilizado está vazio.
+        
+        Examples
+        --------
+        >>> closest_geometry(gdf, Point(x, y))
+        >>> closest_geometry(gdf, (x, y))
+        """
+        
+        if gdf.empty:
+            raise ValueError("GeoDataFrame is Empty.")
+        
+        index_found = 0
+        smallest_dist = float("inf")
+        
+        
+        for index, geom in gdf.geometry.items():
+            dist = geom.distance(point)
+            
+            if dist < smallest_dist:
+                smallest_dist = dist
+                index_found = index
+                geometry_found = geom
+        
+        return index_found, geometry_found
+    
+    def linestring_ini_fim_coordinates(line: LineString) -> tuple[float, float, float, float]:
+        """
+        Extrai as coordenadas inicial e final de uma linha em Lat/Long.
+        
+        Parameters
+        ----------
+        line : shapely.geometry.LineString
+            Alinhamento do qual extrair os extremos.
+        
+        Returns
+        -------
+        tuple of float
+            (start_lat, start_lon, end_lat, end_lon).
+        """
+        
+        start_point = Point(line.coords[0])
+        start_lat = start_point.y
+        start_lon = start_point.x
+        
+        end_point = Point(line.coords[-1])
+        end_lat = end_point.y
+        end_lon = end_point.x
+        
+        return start_lat, start_lon, end_lat, end_lon
+    
+    # ----- Bases -----
+    def EPSG_SIRGAS(zona: int) -> str | None:
+        """
+        Retorna o codigo EPSG (SIRGAS 2000 / UTM) correspondente a uma zona.
+        
+        Parameters
+        ----------
+        zona : int
+            Zona UTM (17 a 25) ou 84 para WGS84 geografico.
+        
+        Returns
+        -------
+        str or None
+            Codigo EPSG no formato "EPSG:XXXXX", ou None se a zona nao for
+            reconhecida.
+        
+        Examples
+        --------
+        >>> EPSG_SIRGAS(23)
+        'EPSG:31983'
+        """
+        tabela = {
+            17: "EPSG:31977",
+            18: "EPSG:31978",
+            19: "EPSG:31979",
+            20: "EPSG:31980",
+            21: "EPSG:31981",
+            22: "EPSG:31982",
+            23: "EPSG:31983",
+            24: "EPSG:31984",
+            25: "EPSG:31985",
+            84: "EPSG:4326",
+        }
+        return tabela.get(zona)
+    
+    def EPSG_SAD(zona: int) -> str | None:
+        """
+        Retorna o codigo EPSG (SAD69 / UTM) correspondente a uma zona.
+        
+        Parameters
+        ----------
+        zona : int
+            Zona UTM (17 a 25) ou 84 para WGS84 geografico.
+        
+        Returns
+        -------
+        str or None
+            Codigo EPSG no formato "EPSG:XXXXX", ou None se a zona nao for
+            reconhecida.
+        
+        Examples
+        --------
+        >>> EPSG_SAD(23)
+        'EPSG:31983'
+        """
+        tabela = {
+            17: "EPSG:29187",
+            18: "EPSG:29188",
+            19: "EPSG:29189",
+            20: "EPSG:29190",
+            21: "EPSG:29191",
+            22: "EPSG:29192",
+            23: "EPSG:29193",
+            24: "EPSG:29194",
+            25: "EPSG:29195",
+            84: "EPSG:4326",
+        }
+        
+        return tabela.get(zona)
+    
+    def read_shape(caminho: str | None = None, epsg: str | None = None) -> gpd.GeoDataFrame:
+        """
+        Le um shapefile como GeoDataFrame.
+        
+        Parameters
+        ----------
+        caminho : str, optional
+            Caminho do arquivo .shp. Se None, usa ALN_PADRAO do .env.
+        epsg : str, optional
+            CRS a atribuir caso o shapefile nao tenha um definido
+            (ex.: "EPSG:4326"). Padrao None.
+        
+        Returns
+        -------
+        geopandas.GeoDataFrame
+            Os dados lidos.
+        
+        Raises
+        ------
+        RuntimeError
+            Se caminho for None e ALN_PADRAO nao estiver definido no .env.
+        
+        Examples
+        --------
+        >>> gdf = read_shape()                       # usa ALN_PADRAO do .env
+        >>> gdf = read_shape("aln.shp", "EPSG:4326")
+        """
+        
+        #warnings.filterwarnings("ignore", category=ShapelyDeprecationWarning)
+        
+        if caminho is None:
+            caminho = config.PATH_BASE_ALN()
+            if caminho is None:
+                raise RuntimeError("read_shape() sem caminho e sem ALN_PADRAO no .env.")
+        
+        df = gpd.read_file(caminho)
+        if df.crs is None and epsg is None:
+            return df
+        elif df.crs is None and epsg is not None:
+            return gpd.GeoDataFrame(df, crs=epsg, geometry="geometry")
+        else:
+            return df
+    
+    def load_SNV() -> gpd.GeoDataFrame:
+        """
+        Carrega e padroniza os SNVs (rede federal + cide) a partir dos
+        caminhos definidos no .env (SNV_FED e SNV_CIDE).
+        
+        Junta as duas fontes, remove SNVs duplicados (preferindo a rede
+        federal), adiciona colunas de lat/long inicial e final e retorna
+        tudo em WGS84.
+        
+        Returns
+        -------
+        geopandas.GeoDataFrame
+            SNVs padronizados em EPSG:4326.
+        
+        Raises
+        ------
+        RuntimeError
+            Se SNV_FED ou SNV_CIDE nao estiverem definidos no .env.
+        
+        Examples
+        --------
+        >>> snv = load_SNV()
+        
+        """
+        fed = config.caminho_snv_fed()
+        cide = config.caminho_snv_cide()
+        if not fed or not cide:
+            raise RuntimeError("load_SNV() requer SNV_FED e SNV_CIDE no .env.")
+        
+        VGEO_fed_df = gpd.read_file(fed)
+        VGEO_std_df = gpd.read_file(cide)
+        
+        filt_fed = ['Codigo_SNV','Codigo_BR','Unidade_Fe','Local_Inic','Quilometra','Local_Fim','Quilometr0','Extensao','Superficie','versao_snv','geometry']
+        filt_std = ['Codigo_SNV','Codigo_Rod','Unidade_Fe','Local_Inic','Quilometra','Local_Fim','Quilometr0','Extensao','Superficie','Referencia','geometry']
+        col_padrao = ['SNV','ROD','UF','inicio','km i','fim','km f','ext','perfil','ref','geometry']
+        
+        VGEO_fed_df = VGEO_fed_df[filt_fed]
+        VGEO_fed_df.columns = col_padrao
+        VGEO_fed_df.insert(7, 'fonte', 'vgeo_snv')
+        
+        VGEO_std_df = VGEO_std_df[filt_std]
+        VGEO_std_df.columns = col_padrao
+        VGEO_std_df.insert(7, 'fonte', 'vgeo_cide')
+        
+        VGEO_fed_df = VGEO_fed_df.to_crs('EPSG:4326')
+        VGEO_std_df = VGEO_std_df.to_crs('EPSG:4326')
+        
+        vgeo_df = pd.concat([VGEO_fed_df, VGEO_std_df])
+        vgeo_df = vgeo_df.drop_duplicates(subset='SNV', keep='first').reset_index(drop=True)
+        vgeo_df[['lat i', 'long i', 'lat f', 'long f']] = vgeo_df['geometry'].apply(
+            lambda x: pd.Series(linestring_ini_fim_coordinates(x)))
+        geometry = vgeo_df.pop('geometry')
+        vgeo_df.insert(len(vgeo_df.columns), 'geometry', geometry)
+        return vgeo_df.to_crs('EPSG:4326')
+    
+    # ------ Aligments -----
+    def point_to_km(gdf: gpd.GeoDataFrame, point, rod=None):
+        """
+        Retorna o km ate um ponto no alinhamento mais proximo (via UTM).
+        
+        Parameters
+        ----------
+        aln_gdf : geopandas.GeoDataFrame
+            Alinhamentos, com colunas ZONA, KM I, NOME e geometry.
+        ponto : shapely.geometry.Point or tuple
+            Ponto de referencia (lon, lat) ou Point.
+        
+        Returns
+        -------
+        tuple
+            (km, nome_do_alinhamento). Retorna ('Erro', ...) quando o ponto
+            esta distante (>300 m) ou em zona UTM incompativel.
+        """
+        
+        if type(point) != shapely.geometry.point.Point:
+            Point(point)
+        
+        closest_index, closest_aln = closest_geometry(gdf, point)
+        
+        ALN = gdf.loc[closest_index,'ALN']
+        
+        # alinhamento final
+        EPSG = gdf.loc[closest_index,'EPSG']
+        
+        gdf_utm = gdf.to_crs(EPSG)
+        aln = gdf_utm.loc[closest_index,'geometry']
+        
+        # calcular km
+        (lon,lat) = point.coords[0]
+        
+        try:
+            point_gdf = gpd.GeoDataFrame(geometry=[point], crs='EPSG:4326')
+            point_gdf_utm = point_gdf.to_crs(EPSG)
+            utm_point = point_gdf_utm.loc[0,'geometry']
+            km = aln.project(utm_point)/1000 + gdf.loc[closest_index, 'km_i']# m
+            KM = float(round(km,3))
+            
+        except:
+            km = "Erro"
+            ALN = "Erro"
+            
+        return (KM,ALN)
+    
+    def km_to_point(aln_gdf: gpd.GeoDataFrame, km: float, rod: str) -> tuple:
+        """
+        Dado um km e uma rodovia, retorna as coordenadas (lat, long) do ponto.
+        
+        Parameters
+        ----------
+        aln_gdf : geopandas.GeoDataFrame
+            Alinhamentos, com colunas ROD, km_i, km_f, EPSG e geometry.
+        km : float
+            Quilometragem desejada.
+        rod : str
+            Rodovia a filtrar.
+        
+        Returns
+        -------
+        tuple of float or None
+            (lat, long) do ponto, ou None se o km/rodovia nao resolver para
+            um unico alinhamento.
+        """
+        # Filtrar dataframe para rodovia desejada
+        gdf = aln_gdf[aln_gdf.ROD == rod]
+        
+        # Encontrar SNV desejado
+        gdf = gdf[(gdf.km_i <= km)&(gdf.km_f > km)]
+        
+        resultados_lat = []
+        resultados_long = []
+        resultados_aln = []
+        
+        if (len(gdf) == 0):
+            return "Erro, não achamos este KM nesta rodovia"
+        
+        elif len(gdf) != 1:
+            for index, row in gdf.iterrows():
+                km_i = row['km_i']
+                line = row['geometry']
+                epsg = row['EPSG']
+                aln = row["ALN"]
+                # Cálculo
+                line_df = gpd.GeoDataFrame(geometry=[line], crs="EPSG:4326")
+                line_df = line_df.to_crs(epsg)
+                line_utm = line_df.loc[0, 'geometry']
+                
+                ponto = line_utm.interpolate((km - km_i) * 1000)
+                ponto_df = gpd.GeoDataFrame(geometry=[ponto], crs=epsg)
+                ponto_df = ponto_df.to_crs("EPSG:4326")
+                long, lat = ponto_df.loc[0, 'geometry'].coords[0]
+                
+                resultados_lat.append(str(round(lat, 8)).replace('.', ','))
+                resultados_long.append(str(round(long, 8)).replace('.', ','))
+                resultados_aln.append(aln)
+                
+            return ', '.join(resultados_lat), ', '.join(resultados_long), ', '.join(resultados_aln)
+        
+        else:
+            # Entradas
+            aln_id = int(gdf.index[0])
+            km_i = gdf.loc[aln_id,'km_i']
+            line = gdf.loc[aln_id,'geometry']
+            epsg = gdf.loc[aln_id,'EPSG']
+            aln = gdf.loc[aln_id, "ALN"]
+            
+            # Cálculo
+            line_df = gpd.GeoDataFrame(geometry=[line],crs="EPSG:4326")
+            line_df = line_df.to_crs(epsg)
+            line_utm = line_df.loc[0,'geometry']
+            
+            ponto = line_utm.interpolate((km-km_i)*1000)
+            ponto_df = gpd.GeoDataFrame(geometry=[ponto],crs = epsg)
+            ponto_df = ponto_df.to_crs("EPSG:4326")
+            long,lat = ponto_df.loc[0,'geometry'].coords[0]
+            
+            # Retornar coordenadas
+            return round(lat,8),round(long,8), aln
+    
+    # ----- SNVs ------
+    def km_snv(snv_gdf: gpd.GeoDataFrame, ponto):
+        """
+        Dado um ponto e SNVs, retorna o km ate o ponto e o SNV mais proximo.
+        
+        Parameters
+        ----------
+        snv_gdf : geopandas.GeoDataFrame
+            SNVs, com colunas 'km i', 'ext', 'SNV' e geometry.
+        ponto : shapely.geometry.Point or tuple
+            Ponto de referencia (lon, lat) ou Point.
+        
+        Returns
+        -------
+        tuple
+            (km, codigo_SNV).
+        """
+        
+        #Transformar coordenadas para ponto
+        if type(ponto) != shapely.geometry.point.Point:
+            Point(ponto)
+        
+        # Correr a lista de SNVs e determinar qual o mais próximo do ponto desejado
+        snv_gdf_id = closest_geometry(snv_gdf, ponto)
+        
+        snv_gdf_id_geometry = snv_gdf.iloc[snv_gdf_id]['geometry']
+        
+        # Calcular a distância ao longo do SNV encontrado até o ponto
+        dist = snv_gdf_id_geometry.project(ponto) # Procura a distancia até o ponto
+        nearest_point = snv_gdf_id_geometry.interpolate(dist) # Gera um ponto mais procimo a distancia
+        
+        # Dividir a extensão proporcionalmente e obter a quilometragem (sem cálculo direto)
+        propini = snv_gdf_id_geometry.project(nearest_point, normalized=True) # Pega a proporção da distancia do snv_gdf até o ponto mais proximo
+        km = snv_gdf.loc[snv_gdf_id, 'km i']+(snv_gdf.loc[snv_gdf_id, 'ext']*propini) # Acha o KM com base na tabela multiplicado pela proporção encontrada até o ponto
+        
+        return km,snv_gdf.loc[snv_gdf_id]['SNV']
+    
+    def km_snv2(snv_gdf: gpd.GeoDataFrame, ponto, data: pd.DataFrame | None = None):
+        """
+        Variante de ``km_snv`` que aceita um DataFrame auxiliar com nomes de
+        SNVs.
+        
+        Parameters
+        ----------
+        snv_gdf : geopandas.GeoDataFrame
+            SNVs, com colunas 'km i', 'ext', 'SNV' e geometry.
+        ponto : shapely.geometry.Point or tuple
+            Ponto de referencia (lon, lat) ou Point.
+        data : pandas.DataFrame, optional
+            Se informado, deve conter as colunas 'longitude', 'latitude' e
+            'name' para localizar o SNV pelo nome. Padrao None.
+        
+        Returns
+        -------
+        tuple
+            (km, codigo_SNV).
+        
+        """
+        # Caso haja algum banco de dados que tenha o nome dos SNVs:
+        if data is not None:
+            for index2,linha in data.iterrows():
+                ponto = (linha['longitude'],linha['latitude'])
+                name = data.iloc[index2]["name"]
+                snv_gdf_id = snv_gdf.index[snv_gdf["SNV"] == name][0]
+                snv_gdf_id_geometry = snv_gdf.iloc[snv_gdf_id]['geometry']
+            
+            # Calcular a distância ao longo do SNV encontrado até o ponto
+            dist = snv_gdf_id_geometry.project(ponto) # Procura a distancia até o ponto
+            nearest_point = snv_gdf_id_geometry.interpolate(dist) # Gera um ponto mais proximo a distancia
+            
+            # Dividir a extensão proporcionalmente e obter a quilometragem (sem cálculo direto)
+            propini = snv_gdf_id_geometry.project(nearest_point, normalized=True) # Pega a proporção da distancia do snv_gdf até o ponto mais proximo
+            km = snv_gdf.loc[snv_gdf_id, 'km i']+(snv_gdf.loc[snv_gdf_id, 'ext']*propini) # Acha o KM com base na tabela multiplicado pela proporção encontrada até o ponto
+            
+        # Caso contrario:
+        else:
+            #Transformar coordenadas para ponto
+            if type(ponto) != shapely.geometry.point.Point:
+                ponto = Point(ponto)
+            
+            
+            # Correr a lista de SNVs e determinar qual o mais próximo do ponto desejado
+            snv_gdf_id = closest_geometry(snv_gdf, ponto)
+            
+            snv_gdf_id_geometry = snv_gdf.iloc[snv_gdf_id]['geometry']
+            
+            # Calcular a distância ao longo do SNV encontrado até o ponto
+            dist = snv_gdf_id_geometry.project(ponto) # Procura a distancia até o ponto
+            nearest_point = snv_gdf_id_geometry.interpolate(dist) # Gera um ponto mais proximo a distancia
+            
+            # Dividir a extensão proporcionalmente e obter a quilometragem (sem cálculo direto)
+            propini = snv_gdf_id_geometry.project(nearest_point, normalized=True) # Pega a proporção da distancia do snv_gdf até o ponto mais proximo
+            km = snv_gdf.loc[snv_gdf_id, 'km i']+(snv_gdf.loc[snv_gdf_id, 'ext']*propini) # Acha o KM com base na tabela multiplicado pela proporção encontrada até o ponto
+            
+        return km,snv_gdf.loc[snv_gdf_id]['SNV']
+    
+    # ----- Shapely ------
+    def cut_linestring(km: float, line: LineString) -> tuple[LineString, LineString]:
+        """
+        Corta um alinhamento em um km especifico, gerando duas linhas.
+        
+        Parameters
+        ----------
+        km : float
+            Quilometragem onde cortar (a partir do inicio da linha).
+        line : shapely.geometry.LineString
+            Alinhamento a cortar.
+        
+        Returns
+        -------
+        tuple of shapely.geometry.LineString
+            (lin1, lin2), onde lin1 + lin2 reconstroem a linha original e o
+            ponto de divisao e o km informado.
+        """
+        comprimento = line.length
+        m = km * 1000
+        corte = line.interpolate(m)
+        projecao = line.project(corte)
+        
+        lin1 = substring(line, 0, projecao)
+        lin2 = substring(line, projecao, comprimento)
+        
+        return lin1, lin2    # onde lin1+lin2 é line, e o ponto de divisão é o km informado
+    
+    def cut_linestring_with_points(aln_gdf: gpd.GeoDataFrame, rod, ponto_a, ponto_b):
+        """
+        Recorta um alinhamento entre dois pontos.
+        
+        Converte cada ponto no km correspondente e delega o corte para
+        ``cortar``.
+        
+        Parameters
+        ----------
+        aln_gdf : geopandas.GeoDataFrame
+            Alinhamentos, com coluna ROD e geometry.
+        rod : str
+            Rodovia a filtrar.
+        ponto_a : shapely.geometry.Point or tuple
+            Ponto inicial do corte.
+        ponto_b : shapely.geometry.Point or tuple
+            Ponto final do corte.
+        
+        Returns
+        -------
+        shapely.geometry.LineString
+            Trecho recortado entre os dois pontos.
+        """
+        # Filtrar dataframe para rodovia desejada (ordenando para o caso de não estar ordenado)
+        line_gdf = aln_gdf[aln_gdf.ROD == rod]
+        
+        # Ajustar ordem (possível apenas por ser a mesma rodovia)
+        km_a = point_to_km(line_gdf, ponto_a, rod)[0][1]
+        km_b = point_to_km(line_gdf, ponto_b, rod)[0][1]
+        
+        # Gerar resultado
+        return cut_linestring(line_gdf, rod, km_a, km_b)
+    
+    # ----- Randoms -----
+    def gms2gd(s: str) -> float:
+        """
+        Converte coordenada de graus-minutos-segundos para graus decimais.
+
+        Parameters
+        ----------
+        s : str
+            Coordenada em GMS, ex.: ``"0°51\'56.29\"S"``. Aceita virgula
+            como separador decimal.
+
+        Returns
+        -------
+        float
+            Valor em graus decimais (negativo para direcoes S, W ou O).
+        """
+        s = s.replace(" ","")
+        
+        if "," in s:
+            s = s.replace(",",".")
+        # example: s = "0°51'56.29"S"
+        degrees, minutes, seconds, direction = re.split('[°\'"]+', s)
+        dd = float(degrees) + float(minutes)/60 + float(seconds)/(60*60);
+        if direction in ('S','W', "O"):
+            dd *= -1
+        return dd

infrapy/interface.py

@@ -0,0 +1,30 @@
+"""interface.py - Interfaces gráficas."""
+
+from pathlib import Path
+import tkinter as tk
+from tkinter import filedialog
+
+
+def tkinter_select_file() -> str | None:
+    """
+    Abre uma janela para seleção de um arquivo.
+    
+    Returns
+    -------
+    str | None
+        Caminho do arquivo selecionado. Retorna ``None`` caso o usuário
+        cancele a seleção.
+    """
+    
+    root = tk.Tk()
+    root.withdraw()
+    root.attributes("-topmost", True)
+    
+    file_path = filedialog.askopenfilename()
+    
+    root.destroy()
+    
+    if not file_path:
+        raise "Usuário não escolheu um arquivo."
+    
+    return file_path

infrapy/mapas.py

@@ -0,0 +1,85 @@
+"""mapas.py - geracao de mapas interativos com Folium."""
+
+if True: # Bibliotecas
+    import json
+    
+    import geopandas as gpd
+    import folium
+    
+    from .cores import cor_aleatoria, cor_aleatoria_variada, cor_aleatoria_predef
+
+if True: # Funcoes
+
+    def mapa_gdf(*gdfs: gpd.GeoDataFrame) -> folium.Map:
+        """
+        Gera um mapa Folium a partir de um ou mais GeoDataFrames.
+        
+        Cada GeoDataFrame e desenhado com uma cor aleatoria e tooltips
+        contendo todas as colunas (exceto geometry). O mapa usa imagem de
+        satelite (Esri World Imagery) como base.
+        
+        Parameters
+        ----------
+        *gdfs : geopandas.GeoDataFrame
+            Um ou mais GeoDataFrames a plotar.
+        
+        Returns
+        -------
+        folium.Map
+            Mapa pronto para exibicao no notebook.
+        
+        Examples
+        --------
+        >>> mapa_gdf(aln_gdf)
+        >>> mapa_gdf(aln_gdf, snv_gdf)
+        """
+        map = folium.Map(location=[-15.83, -47.86], width='100%', height='100%', left='0%', top='0%', position='relative',
+                         tiles='https://server.arcgisonline.com/ArcGIS/rest/services/World_Imagery/MapServer/tile/{z}/{y}/{x}',
+                         attr='Esri', min_zoom=0, max_zoom=18, zoom_start=4, min_lat=-90, max_lat=90, min_lon=-180, max_lon=180,
+                         max_bounds=False, control_scale=False, prefer_canvas=False, no_touch=False, disable_3d=False,
+                         png_enabled=False, zoom_control=True)
+        
+        for gdf in gdfs:
+            JSON = json.loads(gdf.to_json())
+            colunas = [coluna for coluna in gdf.columns if coluna != 'geometry']
+            folium.GeoJson(
+                JSON,
+                tooltip=folium.features.GeoJsonTooltip(fields=colunas, labels=True),
+                style_function=lambda x: {'color': cor_aleatoria_variada()}
+            ).add_to(map)
+        
+        return map
+    
+    def mapa_shapely(shapely_geometries: list, epsg) -> folium.Map:
+        """
+        Gera um mapa Folium a partir de uma lista de geometrias Shapely.
+        
+        As geometrias sao convertidas para WGS84 e desenhadas com cores
+        aleatorias, cada uma com um popup identificando sua ordem.
+        
+        Parameters
+        ----------
+        shapely_geometries : list of shapely geometry
+            Geometrias a plotar.
+        epsg : int or str
+            CRS de origem das geometrias (ex.: 4326 ou "EPSG:31983").
+            
+        Returns
+        -------
+        folium.Map
+            Mapa pronto para exibicao no notebook.
+        """
+        gdf = gpd.GeoDataFrame(geometry=shapely_geometries, crs=epsg)
+        if gdf.crs.to_string() != 'EPSG:4326':
+            gdf = gdf.to_crs(epsg=4326)
+            
+        m = folium.Map(location=[-15.83, -47.86], width='100%', height='100%', left='0%', top='0%', position='relative', tiles='https://server.arcgisonline.com/ArcGIS/rest/services/World_Imagery/MapServer/tile/{z}/{y}/{x}', attr='Esri', min_zoom=0, max_zoom=18, zoom_start=4, min_lat=-90, max_lat=90, min_lon=-180, max_lon=180, max_bounds=False, control_scale=False, prefer_canvas=False, no_touch=False, disable_3d=False, png_enabled=False, zoom_control=True)
+        
+        for idx, geometry in enumerate(gdf['geometry']):
+            cor = cor_aleatoria_variada()
+            nome_geometria = f'Geometria {idx + 1}'
+            popup = folium.Popup(nome_geometria)
+            style_function = lambda x, cor=cor: {'fillColor': cor, 'color': cor}
+            folium.GeoJson(geometry, style_function=style_function, popup=popup).add_to(m)
+            
+        return m

infrapy/sharepoint.py

@@ -0,0 +1,76 @@
+"""sharepoint.py - integracao com SharePoint / Office365.
+
+Credenciais NAO ficam no codigo: sao lidas do .env via infrapy.config.
+"""
+
+if True: # Bibliotecas
+    import os
+    import tempfile
+    
+    import xlwings as xw
+    
+    from office365.runtime.auth.authentication_context import AuthenticationContext
+    from office365.runtime.auth.client_credential import ClientCredential
+    from office365.runtime.auth.user_credential import UserCredential
+    from office365.sharepoint.client_context import ClientContext
+    from office365.sharepoint.files.file import File
+    from office365.sharepoint.folders.folder import Folder
+    from office365.runtime.auth.token_response import TokenResponse
+    from office365.sharepoint.files.system_object_type import FileSystemObjectType
+    from office365.sharepoint.listitems.listitem import ListItem
+    
+    import msal
+    
+    from . import config
+
+if True: # Funcoes
+    
+    def _contexto() -> ClientContext:
+        """
+        Cria um ClientContext autenticado com as credenciais do .env.
+        
+        Returns
+        -------
+        office365.sharepoint.client_context.ClientContext
+            Contexto pronto para consultas ao SharePoint.
+        """
+        site = config.SHAREPOINT_SITE()
+        cert = config.SHAREPOINT_CERTIFICATE()
+        
+        return ClientContext(site).with_client_certificate(**cert)
+    
+    def buscar_arquivos_recursivamente(ctx: ClientContext, directory_url: str):
+        """
+        Gera (yield) todos os arquivos de uma pasta e suas subpastas.
+        
+        Parameters
+        ----------
+        ctx : office365.sharepoint.client_context.ClientContext
+            Contexto autenticado do SharePoint.
+        directory_url : str
+            URL relativa da pasta raiz da busca.
+        
+        Yields
+        ------
+        office365.sharepoint.files.file.File
+            Cada arquivo encontrado, recursivamente.
+        """
+        folder = ctx.web.get_folder_by_server_relative_url(directory_url)
+        ctx.load(folder)
+        ctx.execute_query()
+        
+        # Buscar arquivos na pasta atual
+        files = folder.files
+        ctx.load(files)
+        ctx.execute_query()
+        
+        for file in files:
+            yield file
+            
+        # Buscar arquivos nas subpastas
+        folders = folder.folders
+        ctx.load(folders)
+        ctx.execute_query()
+        
+        for subfolder in folders:
+            yield from buscar_arquivos_recursivamente(ctx, subfolder.properties['ServerRelativeUrl'])

infrapy-0.1.0.dist-info/METADATA

@@ -0,0 +1,100 @@
+Metadata-Version: 2.4
+Name: infrapy
+Version: 0.1.0
+Summary: Biblioteca de funcoes de engenharia civil / rodovias (SNV, alinhamentos, geoprocessamento, Excel, SharePoint)
+Author: Eduardo Abel
+Keywords: engenharia civil,excel,geoprocessamento,rodovias,sharepoint
+Requires-Python: >=3.10
+Requires-Dist: easygui
+Requires-Dist: folium
+Requires-Dist: geopandas
+Requires-Dist: ipython
+Requires-Dist: mapclassify
+Requires-Dist: matplotlib
+Requires-Dist: numpy
+Requires-Dist: office365-rest-python-client
+Requires-Dist: openpyxl
+Requires-Dist: pandas
+Requires-Dist: pyproj
+Requires-Dist: python-dotenv
+Requires-Dist: requests
+Requires-Dist: rtree
+Requires-Dist: scipy
+Requires-Dist: shapely
+Requires-Dist: simplekml
+Requires-Dist: utm
+Requires-Dist: xlsxwriter
+Requires-Dist: xlwings
+Requires-Dist: xyzservices
+Description-Content-Type: text/markdown
+
+# InfraPy
+
+Biblioteca de funcoes de engenharia / rodovias: leitura de shapefiles,
+calculo de km em alinhamentos e SNV, cortes, leitura de Excel (xlwings),
+geracao de mapas Folium, integracao com SharePoint.
+
+## Instalacao (na sua maquina, modo editavel)
+
+Dentro da pasta do projeto (onde esta o `pyproject.toml`):
+
+```bash
+pip install -e .
+```
+
+O `-e` aponta para o codigo-fonte: qualquer alteracao em `src/infrapy/*.py`
+vale na hora (basta reiniciar o kernel), sem reinstalar.
+
+## Instalacao em outra maquina (via GitHub)
+
+```bash
+pip install git+https://github.com/SrBlacky/InfraPy.git
+```
+
+## Configuracao (.env)
+
+Segredos e caminhos pessoais NAO ficam no codigo. Eles vem de um arquivo
+`.env` fora do repositorio.
+
+1. Copie `.env.example` para um `.env` numa pasta segura (fora do OneDrive,
+   ex.: `C:\Users\SEU_USUARIO\.infrapy\.env`).
+2. Preencha os valores.
+3. Ajuste o caminho do `.env` em `src/infrapy/__init__.py` (variavel
+   `_ENV_PATH`) OU defina a variavel de ambiente do Windows `INFRAPY_ENV`
+   apontando para o arquivo.
+
+## Uso
+
+```python
+from infrapy import read_shape, ler_excel, ponto_para_km
+
+aln = read_shape()                 # usa ALN_PADRAO do .env
+ws, df = ler_excel("dados.xlsx", "Plan1", "A1")
+km = ponto_para_km(aln, (-47.9, -15.8))
+```
+
+Ou por modulo:
+
+```python
+from infrapy.geo import cortar, km_para_ponto
+from infrapy.sharepoint import abrir_mef
+```
+
+## Estrutura
+
+```
+InfraPy/
+├── pyproject.toml       identidade e dependencias do pacote
+├── .env.example         modelo de configuracao (versionavel)
+├── .gitignore
+└── src/
+    └── infrapy/
+        ├── __init__.py      carrega o .env e expoe atalhos
+        ├── config.py        le variaveis do ambiente
+        ├── geo.py           geoprocessamento (o grosso das funcoes)
+        ├── excel.py         leitura/escrita de Excel
+        ├── export.py        exportar shp / json->shp
+        ├── mapas.py         mapas Folium
+        ├── cores.py         cores aleatorias
+        └── sharepoint.py    integracao SharePoint
+```

infrapy-0.1.0.dist-info/RECORD

@@ -0,0 +1,12 @@
+infrapy/__init__.py,sha256=oABTbhSRLkGnlND4R7ICMHma1fabaVuU8qO93l9los4,229
+infrapy/config.py,sha256=MNGQwJLnfvFeJw6C_QinlcaT8Idiw7MK8Wx5o295NXA,4592
+infrapy/cores.py,sha256=KyaC2oRBLfGha03JOUQdqvWeJi2D0dqzlln3P2o6B04,4236
+infrapy/excel.py,sha256=pdLxRsKM76apmLn6EA2VrRJddlMflbx5uvBgE497l3Q,4930
+infrapy/export.py,sha256=4OPlVFfA_GZTNZeUuZSJguWhuEtiFafuO1dTLYbqIzI,1192
+infrapy/geo.py,sha256=tQ_7U7mHTo7gIKOfzWS108FDiBq45nKMcmdf0YTv8Ks,20287
+infrapy/interface.py,sha256=-xgh_K1-8d02cKevujKSTm98IZ74FjoWdFqOFMxZtFA,664
+infrapy/mapas.py,sha256=3q1VEKNDVYfHwFIUqWK2PJcUvOSBcd-uS_q63EoGkuQ,3654
+infrapy/sharepoint.py,sha256=U1nntfrp9wluHTc3cwUPpRXNloZXjVbbDo8Frw6gfec,2531
+infrapy-0.1.0.dist-info/METADATA,sha256=Qqwnn_aQTgBwZG2pFW7RZEHRR7dzaiDSvdUfz2DCALU,2932
+infrapy-0.1.0.dist-info/WHEEL,sha256=lCkmxWfQsSc9CfIClYeavTdQeEX2toPqufh9gI35EQA,87
+infrapy-0.1.0.dist-info/RECORD,,

infrapy-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.31.0
+Root-Is-Purelib: true
+Tag: py3-none-any