ESCatastroLib 0.0.1rc3__py2.py3-none-any.whl → 0.0.1rc5__py2.py3-none-any.whl

ESCatastroLib/__about__.py

@@ -1,4 +1,4 @@
 # SPDX-FileCopyrightText: 2025-present Iván V.R <IvanVR@protonmail.com>
 #
 # SPDX-License-Identifier: MIT
-__version__ = '0.0.1rc3'
+__version__ = '0.0.1rc5'

ESCatastroLib/models/InfoCatastral.py

@@ -1,11 +1,14 @@
 import requests
 import json
 import xmltodict
+from datetime import datetime
 
+from shapely import Point
 from typing import Union
+from pyproj import Transformer
 
-from ..utils.statics import URL_BASE_CALLEJERO, URL_BASE_GEOGRAFIA, URL_BASE_CROQUIS_DATOS
-from ..utils.utils import comprobar_errores, listar_sistemas_referencia, lon_lat_from_coords_dict
+from ..utils.statics import URL_BASE_CALLEJERO, URL_BASE_GEOGRAFIA, URL_BASE_CROQUIS_DATOS, URL_BASE_MAPA_VALORES_URBANOS, URL_BASE_MAPA_VALORES_RUSTICOS, URL_BASE_WFS_EDIFICIOS, CULTIVOS
+from ..utils.utils import comprobar_errores, listar_sistemas_referencia, lon_lat_from_coords_dict, lat_lon_from_coords_dict, distancia_entre_dos_puntos_geograficos 
 from ..utils.exceptions import ErrorServidorCatastro
 from ..utils import converters
 from .Calle import Calle, Municipio
@@ -88,6 +91,7 @@ class ParcelaCatastral:
                 'y': parcel_geometry[2*idx]
             } for idx in range(len(parcel_geometry)//2)
         ]
+        self.superficie_total = float(geometry.get('FeatureCollection').get('member').get('cp:CadastralParcel').get('cp:areaValue').get('#text')) 
 
     def __create_from_rc(self, rc: str, projection: str):
         """Create an instance of InfoCatastral from a RC (Referencia Catastral) string."""
@@ -95,7 +99,10 @@ class ParcelaCatastral:
                             params={'RefCat': rc})
         
         if len(req1.content) > 0:
-            info_cadastre = json.loads(req1.content)
+            try:
+                info_cadastre = json.loads(req1.content)
+            except:
+                raise ErrorServidorCatastro(mensaje=f"El servidor no devuelve un JSON. Mensaje en bruto: {req1.content}")
             if comprobar_errores(info_cadastre):
                 cudnp = info_cadastre.get("consulta_dnprcResult", {}).get("control", {}).get("cudnp", 1)
             
@@ -120,6 +127,7 @@ class ParcelaCatastral:
                     self.__create_regions(info_cadastre)
                     self.__create_geometry(projection)
 
+                    self.superficie_construida = sum(float(region.get('superficie')) for region in self.regiones)
                     self.superficie = sum(float(region.get('superficie')) for region in self.regiones)
         else:
             raise ErrorServidorCatastro("El servidor ha devuelto una respuesta vacia")
@@ -134,7 +142,10 @@ class ParcelaCatastral:
                                'Parcela': parcela
                            })
         if len(req.content) > 0:
-            info_cadastre = json.loads(req.content)
+            try:
+                info_cadastre = json.loads(req.content)
+            except:
+                raise ErrorServidorCatastro(mensaje=f"El servidor no devuelve un JSON. Mensaje en bruto: {req1.content}")
             if comprobar_errores(info_cadastre):
                 cudnp = info_cadastre.get("consulta_dnpppResult", {}).get("control", {}).get("cudnp", 1)
 
@@ -168,7 +179,10 @@ class ParcelaCatastral:
                                })
             
             if req.status_code == 200 and len(req.content) > 0 and comprobar_errores(req.json()):
-                info_cadastre = json.loads(req.content)
+                try:
+                    info_cadastre = json.loads(req1.content)
+                except:
+                    raise ErrorServidorCatastro(mensaje=f"El servidor no devuelve un JSON. Mensaje en bruto: {req1.content}")
                 cudnp = info_cadastre.get("consulta_dnplocResult", {}).get("control", {}).get("cudnp", 1)
 
                 if cudnp > 1:
@@ -210,6 +224,219 @@ class ParcelaCatastral:
         else:
             raise ValueError("No se ha proporcionado suficiente información para realizar la búsqueda")
         
+    @property
+    def distancias_aristas(self):
+        """
+            Calcula las distancias entre dos puntos de la geometría, par a par.
+        """
+        if self.geometria:
+            distancias = []
+            for idx in range(0, len(self.geometria)):
+                idx_0 = len(self.geometria)-1 if idx == 0 else idx-1
+                idx_f=idx
+                distancias.append(distancia_entre_dos_puntos_geograficos(
+                    lat_lon_from_coords_dict(self.geometria[idx_0]),
+                    lat_lon_from_coords_dict(self.geometria[idx_f])
+                ))
+            return distancias
+        else: 
+            return None
+
+    @property
+    def perimetro(self):
+        """
+            Calcula el perímetro de la geometría
+        """
+        distancias = self.distancias_aristas
+        if distancias:
+            return sum(distancias)
+        else: 
+            return None
+
+    def valor_catastral_urbano_m2(self, anio):
+        if self.tipo == 'Rústico':
+            return 0
+        
+        req = requests.get(f'{URL_BASE_MAPA_VALORES_URBANOS}',
+                               params={
+                                   "huso":"4326",
+                                   "x":self.centroide['x'],
+                                   "y":self.centroide['y'],
+                                   "anyoZV":anio,
+                                   "suelo": "N",
+                                   "tipo_mapa":"vivienda"
+                               })
+
+        values_map = converters.gpd.read_file(req.content)
+        centroide_point = Point(self.centroide['x'],self.centroide['y'])
+        selected_polygon = values_map[values_map.geometry.covers(centroide_point)]
+
+        return selected_polygon['Ptipo1'].iloc[0].get('val_tipo_m2')
+    
+    @property
+    def numero_plantas(self):
+        """
+        Obtiene el número de plantas de un edificio a partir de su
+        referencia catastral usando el WFS INSPIRE de Catastro.
+
+        Criterio:
+        - Se consultan las BuildingPart
+        - Se toma el máximo número de plantas sobre rasante
+        - Se devuelve también el máximo bajo rasante
+
+        Parameters
+        ----------
+        refcat : str
+            Referencia catastral completa (ej: '9795702WG1499N0001AY')
+        timeout : int
+            Timeout de la petición HTTP en segundos
+
+        Returns
+        -------
+        dict
+            {
+                'refcat': str,
+                'parts': int,
+                'max_above_ground': int | None,
+                'max_below_ground': int,
+                'total_floors': int | None,
+                'parts_detail': list
+            }
+        """
+
+        if self.tipo == 'Rústico':
+            return 0
+
+        params = {
+            "service": "WFS",
+            "version": "2.0.0",
+            "request": "GetFeature",
+            "STOREDQUERIE_ID": "GetBuildingPartByParcel",
+            "REFCAT": self.rc,
+            "srsname": "EPSG:4326"
+        }
+
+        response = requests.get(URL_BASE_WFS_EDIFICIOS, params=params)
+        response.raise_for_status()
+
+        data = xmltodict.parse(response.content)
+
+        feature_collection = data.get("gml:FeatureCollection", {})
+        members = feature_collection.get("gml:featureMember", [])
+
+        if isinstance(members, dict):
+            members = [members]
+
+        above_floors = []
+        below_floors = []
+        parts_detail = []
+
+        for member in members:
+            bp = member.get("bu-ext2d:BuildingPart")
+            if not bp:
+                continue
+
+            part_id = bp.get("@gml:id")
+
+            above = bp.get("bu-ext2d:numberOfFloorsAboveGround")
+            below = bp.get("bu-ext2d:numberOfFloorsBelowGround")
+
+            above_i = int(above) if above is not None else None
+            below_i = int(below) if below is not None else 0
+
+            if above_i is not None:
+                above_floors.append(above_i)
+            below_floors.append(below_i)
+
+            parts_detail.append({
+                "id": part_id,
+                "floors_above_ground": above_i,
+                "floors_below_ground": below_i
+            })
+
+        return {
+            "partes": parts_detail,
+            "plantas": max(above_floors) if above_floors else None,
+            "sotanos": max(below_floors) if below_floors else 0,
+            "total": (
+                max(above_floors) + max(below_floors)
+                if above_floors else None
+            )
+        }
+    
+    def valor_catastral_rustico_m2(self, anio:str):
+        """
+        Obtiene los valores catastrales de tierras a partir de una referencia catastral.
+
+        Args:
+            referencia_catastral (str): Referencia catastral de la parcela.
+
+        Returns:
+            dict: Datos de la parcela con región y módulos €/ha, o None si no se encuentran.
+        """
+
+        if self.tipo == "Urbano":
+            return {}
+
+        geometria = self.geometria
+
+        # Transformar geometría EPSG:4381 → EPSG:3857
+        transformer = Transformer.from_crs("EPSG:4381", "EPSG:3857", always_xy=True)
+        xs_3857 = []
+        ys_3857 = []
+        for p in geometria:
+            x, y = transformer.transform(p["x"], p["y"])
+            xs_3857.append(x)
+            ys_3857.append(y)
+
+        # BBOX EPSG:3857
+        bbox = f"{min(xs_3857)},{min(ys_3857)},{max(xs_3857)},{max(ys_3857)}"
+
+        params = {
+            "SERVICE": "WMS",
+            "VERSION": "1.3.0",
+            "REQUEST": "GetFeatureInfo",
+            "LAYERS": f"IAMIR{int(str(anio)[-2:])-1}:athiamir{int(str(anio)[-2:])-1}",
+            "QUERY_LAYERS": f"IAMIR{int(str(anio)[-2:])-1}:athiamir{int(str(anio)[-2:])-1}",
+            "STYLES": "",
+            "CRS": "EPSG:3857",
+            "SRS": "EPSG:3857",
+            "BBOX": bbox,
+            "WIDTH": 101,
+            "HEIGHT": 101,
+            "FORMAT": "image/png",
+            "TRANSPARENT": "true",
+            "I": 55,
+            "J": 55,
+            "INFO_FORMAT": "application/json"
+        }
+
+        r = requests.get(URL_BASE_MAPA_VALORES_RUSTICOS, params=params, timeout=15)
+        r.raise_for_status()
+        data = r.json()
+
+        if not data.get("features"):
+            return None
+
+        props = data["features"][0]["properties"]
+
+        modulos = {
+            "region": props.get("REGIONAL"),
+            "nombre_region": props.get("NOMBRE"),
+            "modulos_€/ha": {}
+        }
+
+        for cod, desc in CULTIVOS.items():
+            val = props.get(cod)
+            if isinstance(val, (int, float)) and val > 0:
+                modulos["modulos_€/ha"][desc] = val
+
+        return {
+            "region": modulos["region"],
+            "nombre_region": modulos["nombre_region"],
+            "modulos_€/ha": modulos["modulos_€/ha"]
+        }
+        
 
     def to_dataframe(self):
         """

ESCatastroLib/utils/converters.py

@@ -17,7 +17,8 @@ def to_geodataframe(parcelas: list) -> gpd.GeoDataFrame:
     return gpd.GeoDataFrame({
                     "rc": pc.rc,
                     "tipo": pc.tipo,
-                    "superficie": pc.superficie,
+                    "superficie_total": pc.superficie_total,
+                    "superficie_construida": pc.superficie_construida,
                     "provincia": pc.provincia, 
                     "municipio": pc.municipio, 
                     "regiones": ','.join([f"{reg.get('descripcion')} ({reg.get('superficie')} m^2)" for reg in pc.regiones]) , 

ESCatastroLib/utils/statics.py

@@ -1,8 +1,11 @@
 URL_BASE_CALLEJERO = 'https://ovc.catastro.meh.es/OVCServWeb/OVCWcfCallejero/COVCCallejero.svc/json'
 URL_BASE_COORDENADAS = 'https://ovc.catastro.meh.es/OVCServWeb/OVCWcfCallejero/COVCCoordenadas.svc/json'
 URL_BASE_GEOGRAFIA = 'http://ovc.catastro.meh.es/INSPIRE/wfsCP.aspx'
+URL_BASE_WFS_EDIFICIOS = "https://ovc.catastro.meh.es/INSPIRE/wfsBU.aspx"
 URL_BASE_CROQUIS_DATOS = f'https://www1.sedecatastro.gob.es/CYCBienInmueble/SECImprimirCroquisYDatos.aspx'
 URL_BASE_CARTOCIUDAD_GEOCODER = 'https://www.cartociudad.es/geocoder/api/geocoder'
+URL_BASE_MAPA_VALORES_URBANOS = "https://www1.sedecatastro.gob.es/Cartografia/SECDameGeoJSON.aspx"
+URL_BASE_MAPA_VALORES_RUSTICOS = "https://www1.sedecatastro.gob.es/Cartografia/GeoServerWMS.aspx"
 
 MAPEOS_PROVINCIAS = {
     'La Coruña': 'A Coruña',
@@ -138,4 +141,32 @@ SISTEMAS_REFERENCIA = {
     'EPSG:23029': 'UTM huso 29N en ED50',
     'EPSG:23030': 'UTM huso 30N en ED50',
     'EPSG:23031': 'UTM huso 31N en ED50'
-}
+}
+
+CULTIVOS = {
+        "ARZ": "Arrozal",
+        "CBP": "Cultivos bajo plástico",
+        "CIT": "Cítricos",
+        "FCR": "Frutal carnoso regadío",
+        "FCS": "Frutal carnoso secano",
+        "FSR": "Frutos secos regadío",
+        "FSS": "Frutos secos secano",
+        "HUE": "Huerta",
+        "OLR": "Olivar regadío",
+        "OLS": "Olivar secano",
+        "PLT": "Plátanos",
+        "SBT": "Cultivos tropicales y subtropicales",
+        "TAR": "Tierras arables regadío",
+        "TAS": "Tierras arables secano",
+        "VIP": "Viñedo parral",
+        "VIR": "Viñedo regadío",
+        "VIS": "Viñedo secano",
+        "VOL": "Viña olivar",
+        "PAR": "Pasto con arbolado",
+        "PRD": "Prados",
+        "PST": "Pastizal",
+        "CON": "Coníferas",
+        "FRL": "Frondosas de crecimiento lento",
+        "FRR": "Frondosas de crecimiento rápido",
+        "MTR": "Matorral"
+    }

ESCatastroLib/utils/test_plantas.py

@@ -0,0 +1,109 @@
+import requests
+import xmltodict
+
+
+WFS_URL = "https://ovc.catastro.meh.es/INSPIRE/wfsBU.aspx"
+
+
+def get_building_floors_by_refcat(refcat, timeout=30):
+    """
+    Obtiene el número de plantas de un edificio a partir de su
+    referencia catastral usando el WFS INSPIRE de Catastro.
+
+    Criterio:
+      - Se consultan las BuildingPart
+      - Se toma el máximo número de plantas sobre rasante
+      - Se devuelve también el máximo bajo rasante
+
+    Parameters
+    ----------
+    refcat : str
+        Referencia catastral completa (ej: '9795702WG1499N0001AY')
+    timeout : int
+        Timeout de la petición HTTP en segundos
+
+    Returns
+    -------
+    dict
+        {
+            'refcat': str,
+            'parts': int,
+            'max_above_ground': int | None,
+            'max_below_ground': int,
+            'total_floors': int | None,
+            'parts_detail': list
+        }
+    """
+
+    params = {
+        "service": "WFS",
+        "version": "2.0.0",
+        "request": "GetFeature",
+        "STOREDQUERIE_ID": "GetBuildingPartByParcel",
+        "REFCAT": refcat,
+        "srsname": "EPSG:4326"
+    }
+
+    response = requests.get(WFS_URL, params=params, timeout=timeout)
+    response.raise_for_status()
+
+    data = xmltodict.parse(response.content)
+
+    feature_collection = data.get("gml:FeatureCollection", {})
+    members = feature_collection.get("gml:featureMember", [])
+
+    if isinstance(members, dict):
+        members = [members]
+
+    above_floors = []
+    below_floors = []
+    parts_detail = []
+
+    for member in members:
+        bp = member.get("bu-ext2d:BuildingPart")
+        if not bp:
+            continue
+
+        part_id = bp.get("@gml:id")
+
+        above = bp.get("bu-ext2d:numberOfFloorsAboveGround")
+        below = bp.get("bu-ext2d:numberOfFloorsBelowGround")
+
+        above_i = int(above) if above is not None else None
+        below_i = int(below) if below is not None else 0
+
+        if above_i is not None:
+            above_floors.append(above_i)
+        below_floors.append(below_i)
+
+        parts_detail.append({
+            "id": part_id,
+            "floors_above_ground": above_i,
+            "floors_below_ground": below_i
+        })
+
+    return {
+        "refcat": refcat,
+        "parts": len(parts_detail),
+        "max_above_ground": max(above_floors) if above_floors else None,
+        "max_below_ground": max(below_floors) if below_floors else 0,
+        "total_floors": (
+            max(above_floors) + max(below_floors)
+            if above_floors else None
+        ),
+        "parts_detail": parts_detail
+    }
+
+
+# -------------------------------------------------------
+# Ejemplo de uso
+# -------------------------------------------------------
+if __name__ == "__main__":
+    refcat = "6225302WG2662E0024ZJ"
+    result = get_building_floors_by_refcat(refcat)
+
+    print("Referencia:", result["refcat"])
+    print("Partes:", result["parts"])
+    print("Plantas sobre rasante:", result["max_above_ground"])
+    print("Plantas bajo rasante:", result["max_below_ground"])
+    print("Total plantas:", result["total_floors"])

ESCatastroLib/utils/test_valor_catastral_tierras.py

@@ -0,0 +1,136 @@
+import requests
+from escatastrolib import ParcelaCatastral
+from pyproj import Transformer
+
+WMS_URL = "https://www1.sedecatastro.gob.es/Cartografia/GeoServerWMS.aspx"
+LAYER = "IAMIR26:athiamir26"
+WIDTH = 101
+HEIGHT = 101
+I = WIDTH // 2
+J = HEIGHT // 2
+
+CULTIVOS = {
+    "ARZ": "Arrozal",
+    "CBP": "Cultivos bajo plástico",
+    "CIT": "Cítricos",
+    "FCR": "Frutal carnoso regadío",
+    "FCS": "Frutal carnoso secano",
+    "FSR": "Frutos secos regadío",
+    "FSS": "Frutos secos secano",
+    "HUE": "Huerta",
+    "OLR": "Olivar regadío",
+    "OLS": "Olivar secano",
+    "PLT": "Plátanos",
+    "SBT": "Cultivos tropicales y subtropicales",
+    "TAR": "Tierras arables regadío",
+    "TAS": "Tierras arables secano",
+    "VIP": "Viñedo parral",
+    "VIR": "Viñedo regadío",
+    "VIS": "Viñedo secano",
+    "VOL": "Viña olivar",
+    "PAR": "Pasto con arbolado",
+    "PRD": "Prados",
+    "PST": "Pastizal",
+    "CON": "Coníferas",
+    "FRL": "Frondosas de crecimiento lento",
+    "FRR": "Frondosas de crecimiento rápido",
+    "MTR": "Matorral"
+}
+
+
+def obtener_valor_catastral_tierras(referencia_catastral):
+    """
+    Obtiene los valores catastrales de tierras a partir de una referencia catastral.
+
+    Args:
+        referencia_catastral (str): Referencia catastral de la parcela.
+
+    Returns:
+        dict: Datos de la parcela con región y módulos €/ha, o None si no se encuentran.
+    """
+    parcela = ParcelaCatastral(referencia_catastral)
+    geometria = parcela.geometria  # EPSG:4381
+
+    # Transformar geometría EPSG:4381 → EPSG:3857
+    transformer = Transformer.from_crs("EPSG:4381", "EPSG:3857", always_xy=True)
+    xs_3857 = []
+    ys_3857 = []
+    for p in geometria:
+        x, y = transformer.transform(p["x"], p["y"])
+        xs_3857.append(x)
+        ys_3857.append(y)
+
+    # BBOX EPSG:3857
+    bbox = f"{min(xs_3857)},{min(ys_3857)},{max(xs_3857)},{max(ys_3857)}"
+
+    params = {
+        "SERVICE": "WMS",
+        "VERSION": "1.3.0",
+        "REQUEST": "GetFeatureInfo",
+        "LAYERS": LAYER,
+        "QUERY_LAYERS": LAYER,
+        "STYLES": "",
+        "CRS": "EPSG:3857",
+        "SRS": "EPSG:3857",
+        "BBOX": bbox,
+        "WIDTH": WIDTH,
+        "HEIGHT": HEIGHT,
+        "FORMAT": "image/png",
+        "TRANSPARENT": "true",
+        "I": I,
+        "J": J,
+        "INFO_FORMAT": "application/json"
+    }
+
+    r = requests.get(WMS_URL, params=params, timeout=15)
+    r.raise_for_status()
+    data = r.json()
+
+    if not data.get("features"):
+        return None
+
+    props = data["features"][0]["properties"]
+
+    modulos = {
+        "region": props.get("REGIONAL"),
+        "nombre_region": props.get("NOMBRE"),
+        "modulos_€/ha": {}
+    }
+
+    for cod, desc in CULTIVOS.items():
+        val = props.get(cod)
+        if isinstance(val, (int, float)) and val > 0:
+            modulos["modulos_€/ha"][desc] = val
+
+    return {
+        "referencia_catastral": referencia_catastral,
+        "provincia": parcela.provincia,
+        "municipio": parcela.municipio,
+        "superficie_m2": parcela.superficie,
+        "region": modulos["region"],
+        "nombre_region": modulos["nombre_region"],
+        "modulos_€/ha": modulos["modulos_€/ha"]
+    }
+
+
+# =========================================================
+# EJEMPLO DE USO
+# =========================================================
+
+if __name__ == "__main__":
+    rc = "18030A014004610000RH"  # ejemplo
+    resultado = obtener_valor_catastral_tierras(rc)
+
+    if resultado:
+        print(f"RC: {resultado['referencia_catastral']}")
+        print(f"{resultado['municipio']} ({resultado['provincia']})")
+        print(f"Superficie: {resultado['superficie_m2']:.0f} m²")
+        print(f"Región: {resultado['region']} – {resultado['nombre_region']}\n")
+        for uso, valor in sorted(
+            resultado["modulos_€/ha"].items(),
+            key=lambda x: x[1],
+            reverse=True
+        ):
+            print(f"{uso}: {valor:,.0f} €/Ha")
+    else:
+        print("No se encontraron módulos catastrales para esta parcela.")

ESCatastroLib/utils/utils.py

@@ -1,7 +1,9 @@
 import requests
 import json
 
-from typing import Union
+from geopy.distance import geodesic
+
+from typing import Union, List
 
 from .statics import URL_BASE_CALLEJERO, MAPEOS_PROVINCIAS, TIPOS_VIA, SISTEMAS_REFERENCIA, URL_BASE_COORDENADAS, URL_BASE_CARTOCIUDAD_GEOCODER
 from .exceptions import lanzar_excepcion
@@ -200,14 +202,35 @@ def geocodificar_direccion(direccion: str, municipio: str = None):
     
     if response.status_code == 200:
         data = json.loads(response.content.decode('utf-8').replace('callback(', '').replace(')', ''))
-        return {
-            'x': data.get('lng'),
-            'y': data.get('lat'),
-            'rc': data.get('refCatastral')
-        }
+        print(data)
+        if type(data) == dict:
+           return {
+                'x': data.get('lng'),
+                'y': data.get('lat'),
+                'rc': data.get('refCatastral')
+            }
+        elif type(data) == list and len(data) > 0:
+            pc = data[0]
+            return {
+                'x': pc.get('lng'),
+                'y': pc.get('lat'),
+                'rc': pc.get('refCatastral')
+            }
+        else:
+            return None
     else:
         return None
             
 def lon_lat_from_coords_dict(coords):
     return float(coords["x"]), float(coords["y"])
 
+def lat_lon_from_coords_dict(coords):
+    return float(coords['y']), float(coords['x'])
+
+def distancia_entre_dos_puntos_geograficos(origen: List[float], destino: List[float]):
+    """
+        Devuelve la distancia en metros entre dos puntos geográficos usando latitud y longitud.
+        ¡OJO! Las tuplas deben ser latitud y longitud y no al revés.
+    """
+    return geodesic(origen,destino).m
+    

{escatastrolib-0.0.1rc3.dist-info → escatastrolib-0.0.1rc5.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ESCatastroLib
-Version: 0.0.1rc3
+Version: 0.0.1rc5
 Summary: Una librería de Python para consultar los datos del Catastro COMO OBJETOS. Incluye información geográfica.
 Project-URL: Documentation, https://github.com/IvanitiX/ESCatastroLib#readme
 Project-URL: Issues, https://github.com/IvanitiX/ESCatastroLib/issues
@@ -10,7 +10,6 @@ License: Apache License (2.0)
 License-File: LICENSE
 Keywords: catastro,espana,gis,spain
 Classifier: Development Status :: 3 - Alpha
-Classifier: Framework :: Pytest
 Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: Apache Software License
 Classifier: Natural Language :: Spanish
@@ -19,6 +18,7 @@ Classifier: Programming Language :: Python :: 3
 Classifier: Topic :: Software Development :: Build Tools
 Requires-Dist: folium
 Requires-Dist: geopandas
+Requires-Dist: geopy
 Requires-Dist: pyarrow
 Requires-Dist: pytest
 Requires-Dist: requests
@@ -267,8 +267,8 @@ Un archivo con el `filename`.
 ¡Buena pregunta! Os dejo algunos ejemplos:
 
 ```python
-from escatastrolib import Municipio, Calle, ParcelaCatastral, MetaParcela
-from escatastrolib.utils import listar_provincias, listar_tipos_via, listar_calles, listar_municipios
+from ESCatastroLib import Municipio, Calle, ParcelaCatastral, MetaParcela
+from ESCatastroLib.utils import listar_provincias, listar_tipos_via, listar_calles, listar_municipios
 
 print(listar_provincias())
 # > ['A CORUÑA', 'ALACANT', 'ALBACETE', 'ALMERIA', 'ASTURIAS', 'AVILA', 'BADAJOZ', ...]
@@ -364,4 +364,4 @@ Sigue las instrucciones de CONTRIBUTING.md y el Código de Conducta.
 
 [1]: https://github.com/gisce/pycatastro
 [2]: https://github.com/astrojuanlu
-[3]: https://github.com/JaimeObregon
+[3]: https://github.com/JaimeObregon

escatastrolib-0.0.1rc5.dist-info/RECORD

@@ -0,0 +1,17 @@
+ESCatastroLib/__about__.py,sha256=4Gd4-yBRspaqdiFVWu4WyG_F7tAMkrybx_WdUxj5x1U,131
+ESCatastroLib/__init__.py,sha256=QCXZ5qTCAGhkZr63i0Y7zZpkLKd342edUzjt9U_Ujqs,220
+ESCatastroLib/models/Calle.py,sha256=TfgJfRiCSl6Fgug2--Wo2x5cj6JQdhHQojtZDZOgVSo,2846
+ESCatastroLib/models/InfoCatastral.py,sha256=IJGrx0QAtfPSeXDss24lSorGMsyfwiWu6S2PChqCyY0,31362
+ESCatastroLib/models/Municipio.py,sha256=J3X9G7EMc63651EDAMOqo846Ed-5cVjJfZLZeohPw74,1566
+ESCatastroLib/models/__init__.py,sha256=Y8nN1Qp3_-VX7njuXwFWSq-62clHj878miEQGnzNXlc,149
+ESCatastroLib/utils/__init__.py,sha256=kQj0ORkR_JMgwWgGi73APqn3p-UQipiuMY1QaBBmkLs,106
+ESCatastroLib/utils/converters.py,sha256=JFRuFvIidRxVJitCPukHAcFsraIuqR-hfSaU0vleGfU,2705
+ESCatastroLib/utils/exceptions.py,sha256=YM3AuKHZ61SYgpmtYFz9n7JavdEOq2mLwyk2VzIol5A,759
+ESCatastroLib/utils/statics.py,sha256=YZ202WkreqsPKwhVxuNDVBWagobYWUIJdbh6vBw_b2s,5169
+ESCatastroLib/utils/test_plantas.py,sha256=iCXxktsAnWDe8dniAsLWKBHFUKBQppf9GAzpE-_ut9c,3083
+ESCatastroLib/utils/test_valor_catastral_tierras.py,sha256=Kjb-RiAPW0Sq4qBgk8BNd3cTM1cXi2vXSpCyMHLdvqk,4057
+ESCatastroLib/utils/utils.py,sha256=mecrCnjlJX8dA1edmsRhEP_3MfIR68GFxtfTUfIHGEE,9218
+escatastrolib-0.0.1rc5.dist-info/METADATA,sha256=dadx4qWDYpI9OWMy9mGOez1pbKcBTYzbW3lJ2482e8Y,18056
+escatastrolib-0.0.1rc5.dist-info/WHEEL,sha256=tkmg4JIqwd9H8mL30xA7crRmoStyCtGp0VWshokd1Jc,105
+escatastrolib-0.0.1rc5.dist-info/licenses/LICENSE,sha256=kgDY5GRu9WGoKk_0F0iYmXuLmGiZ9hgtReHhCfJBWr8,11319
+escatastrolib-0.0.1rc5.dist-info/RECORD,,

escatastrolib-0.0.1rc3.dist-info/RECORD

@@ -1,15 +0,0 @@
-ESCatastroLib/__about__.py,sha256=vsaWW_x-_9_aeEMTHUfLee5bPKUCtQ2XFAWd6MBIpyQ,131
-ESCatastroLib/__init__.py,sha256=QCXZ5qTCAGhkZr63i0Y7zZpkLKd342edUzjt9U_Ujqs,220
-ESCatastroLib/models/Calle.py,sha256=TfgJfRiCSl6Fgug2--Wo2x5cj6JQdhHQojtZDZOgVSo,2846
-ESCatastroLib/models/InfoCatastral.py,sha256=H8Eo96OThC_OSnpQ7Jeuwo4We5f1XZ4C51lbvcDUSq4,23308
-ESCatastroLib/models/Municipio.py,sha256=J3X9G7EMc63651EDAMOqo846Ed-5cVjJfZLZeohPw74,1566
-ESCatastroLib/models/__init__.py,sha256=Y8nN1Qp3_-VX7njuXwFWSq-62clHj878miEQGnzNXlc,149
-ESCatastroLib/utils/__init__.py,sha256=kQj0ORkR_JMgwWgGi73APqn3p-UQipiuMY1QaBBmkLs,106
-ESCatastroLib/utils/converters.py,sha256=cxjesg23z0gxhaquuPaEQjhgb2Gnj5Ip2BqX_n3wY0s,2621
-ESCatastroLib/utils/exceptions.py,sha256=YM3AuKHZ61SYgpmtYFz9n7JavdEOq2mLwyk2VzIol5A,759
-ESCatastroLib/utils/statics.py,sha256=PpHPS-lopMYWg5pJeeCU5NtIJU6nUpeh9njFFKwfVfc,3958
-ESCatastroLib/utils/utils.py,sha256=WdtW7NqkFH0erkqRXbPAQRJQmJXezSjbD6mmJK8OZ-4,8436
-escatastrolib-0.0.1rc3.dist-info/METADATA,sha256=IyW6cvq6iaKl3Ej55r1cL3TnNLfNhHzxfLWhI2hkI4w,18066
-escatastrolib-0.0.1rc3.dist-info/WHEEL,sha256=tkmg4JIqwd9H8mL30xA7crRmoStyCtGp0VWshokd1Jc,105
-escatastrolib-0.0.1rc3.dist-info/licenses/LICENSE,sha256=kgDY5GRu9WGoKk_0F0iYmXuLmGiZ9hgtReHhCfJBWr8,11319
-escatastrolib-0.0.1rc3.dist-info/RECORD,,