ESCatastroLib 0.0.1rc5__py2.py3-none-any.whl → 1.0.0__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.1rc5'
+__version__ = '1.0.0'

ESCatastroLib/models/InfoCatastral.py

@@ -3,8 +3,8 @@ import json
 import xmltodict
 from datetime import datetime
 
-from shapely import Point
-from typing import Union
+from shapely.geometry import Point
+from typing import Union, Dict, Any, Optional, List
 from pyproj import Transformer
 
 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
@@ -13,7 +13,98 @@ from ..utils.exceptions import ErrorServidorCatastro
 from ..utils import converters
 from .Calle import Calle, Municipio
 
-class ParcelaCatastral:
+
+class ParcelaHelper:
+    """Clase base con métodos compartidos para operaciones de parcelas catastrales."""
+    
+    def _llamar_a_api(self, url: str, params: Dict[str, Any], timeout: int = 30) -> requests.Response:
+        """Realiza una petición HTTP a la API del Catastro.
+        
+        Args:
+            url: URL del endpoint a consultar
+            params: Parámetros de la petición HTTP
+            timeout: Tiempo máximo de espera en segundos
+            
+        Returns:
+            Objeto Response con la respuesta del servidor
+            
+        Raises:
+            ErrorServidorCatastro: Si el servidor devuelve una respuesta vacía o error
+        """
+        response = requests.get(url, params=params, timeout=timeout)
+        
+        if len(response.content) == 0:
+            raise ErrorServidorCatastro("El servidor ha devuelto una respuesta vacía")
+            
+        return response
+    
+    def _parsear_respuesta(self, response: requests.Response) -> Dict[str, Any]:
+        """Parsea la respuesta JSON de la API del Catastro.
+        
+        Args:
+            response: Objeto Response de la petición HTTP
+            
+        Returns:
+            Diccionario con los datos parseados
+            
+        Raises:
+            ErrorServidorCatastro: Si el servidor no devuelve un JSON válido
+        """
+        try:
+            return response.json()
+        except json.JSONDecodeError:
+            raise ErrorServidorCatastro(
+                mensaje=f"El servidor no devuelve un JSON. Mensaje en bruto: {response.content}"
+            )
+    
+    def _parametrizar_peticion(self, **kwargs) -> Dict[str, Any]:
+        """Construye un diccionario de parámetros para la petición HTTP.
+        
+        Args:
+            **kwargs: Parámetros clave-valor para la petición
+            
+        Returns:
+            Diccionario con los parámetros filtrados (solo valores no nulos)
+        """
+        return {k: v for k, v in kwargs.items() if v is not None}
+    
+    def _comprobar_errores_catastro(self, info_cadastre: Dict[str, Any]) -> bool:
+        """Verifica si la respuesta del Catastro contiene errores.
+        
+        Args:
+            info_cadastre: Diccionario con la respuesta del Catastro
+            
+        Returns:
+            True si no hay errores, False si hay errores
+        """
+        return comprobar_errores(info_cadastre)
+    
+    def _obtener_numero_parcelas(self, info_cadastre: Dict[str, Any], consulta_key: str) -> int:
+        """Obtiene el número de parcelas de una respuesta del Catastro.
+        
+        Args:
+            info_cadastre: Diccionario con la respuesta del Catastro
+            consulta_key: Clave de la consulta ('dnprc', 'dnppp', 'dnploc')
+            
+        Returns:
+            Número de parcelas encontradas
+        """
+        result_key = f"consulta_{consulta_key}Result"
+        return info_cadastre.get(result_key, {}).get("control", {}).get("cudnp", 1)
+    
+    def _extraer_rc_from_dict(self, rc_dict: Dict[str, Any]) -> str:
+        """Extrae la referencia catastral de un diccionario.
+        
+        Args:
+            rc_dict: Diccionario que contiene la referencia catastral
+            
+        Returns:
+            Referencia catastral como string
+        """
+        return ''.join(rc_dict.values())
+
+
+class ParcelaCatastral(ParcelaHelper):
     """
     Clase que representa una parcela catastral.
     Args:
@@ -48,7 +139,15 @@ class ParcelaCatastral:
         geometria (list): Una lista de puntos que representan la geometría de la parcela.
     """
 
-    def __create_regions(self, info_cadastre: dict):
+    def __create_regions(self, info_cadastre: Dict[str, Any]) -> None:
+        """Crea la lista de regiones de la parcela a partir de los datos del Catastro.
+        
+        Args:
+            info_cadastre: Diccionario con la respuesta del Catastro.
+            
+        Attributes:
+            regiones: Lista de diccionarios con 'descripcion' y 'superficie' de cada región.
+        """
         self.regiones = []
         if self.tipo == 'Urbano':
             iterator = list(info_cadastre.values())[0].get('bico').get('lcons')
@@ -67,18 +166,26 @@ class ParcelaCatastral:
                     })
 
 
-    def __create_geometry(self, projection: str = 'EPSG:4326'):
-        geometry_request = requests.get(f'{URL_BASE_GEOGRAFIA}',
-                                        params={
-                                            'service':'wfs',
-                                            'version':'2',
-                                            'request':'getfeature',
-                                            'STOREDQUERIE_ID':'GetParcel',
-                                            'refcat': self.rc,
-                                            'srsname': projection
-                                        })
-
-        geometry = xmltodict.parse(geometry_request.content)
+    def __create_geometry(self, projection: str = 'EPSG:4326') -> None:
+        """Crea la geometría de la parcela consultando el servicio WFS.
+        
+        Args:
+            projection: Sistema de referencia espacial (EPSG). Por defecto 'EPSG:4326'.
+            
+        Raises:
+            ErrorServidorCatastro: Si el servidor devuelve una respuesta vacía o error.
+        """
+        params = self._parametrizar_peticion(
+            service='wfs',
+            version='2',
+            request='getfeature',
+            STOREDQUERIE_ID='GetParcel',
+            refcat=self.rc,
+            srsname=projection
+        )
+        response = self._llamar_a_api(f'{URL_BASE_GEOGRAFIA}', params)
+        
+        geometry = xmltodict.parse(response.content)
         geoposition = geometry.get('FeatureCollection').get('member').get('cp:CadastralParcel').get('cp:referencePoint').get('gml:Point').get('gml:pos').split(' ')
         self.centroide = {
             'x': geoposition[1],
@@ -95,67 +202,56 @@ class ParcelaCatastral:
 
     def __create_from_rc(self, rc: str, projection: str):
         """Create an instance of InfoCatastral from a RC (Referencia Catastral) string."""
-        req1 = requests.get(f'{URL_BASE_CALLEJERO}/Consulta_DNPRC',
-                            params={'RefCat': rc})
+        params = self._parametrizar_peticion(RefCat=rc)
+        response = self._llamar_a_api(f'{URL_BASE_CALLEJERO}/Consulta_DNPRC', params)
+        info_cadastre = self._parsear_respuesta(response)
         
-        if len(req1.content) > 0:
-            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)
-            
-                if cudnp > 1:
-                    raise ErrorServidorCatastro(mensaje="Esta parcela tiene varias referencias catastrales. Usa un objeto MetaParcela.")
-                else:
-                    self.rc = ''.join(info_cadastre.get('consulta_dnprcResult').get('bico').get('bi').get('idbi').get('rc').values())
-                    self.url_croquis = requests.get(URL_BASE_CROQUIS_DATOS, params={'refcat': self.rc}).url
-                    self.municipio = info_cadastre.get('consulta_dnprcResult').get('bico').get('bi').get('dt').get('nm')
-                    self.provincia = info_cadastre.get('consulta_dnprcResult').get('bico').get('bi').get('dt').get('np')
-                    self.tipo = 'Rústico' if info_cadastre.get('consulta_dnprcResult').get('bico').get('bi').get('idbi').get('cn') == 'RU' else 'Urbano'
-                    if self.tipo == 'Urbano':
-                        self.calle = f"{info_cadastre.get('consulta_dnprcResult').get('bico').get('bi').get('dt').get('locs').get('lous').get('lourb').get('dir').get('tv')} {info_cadastre.get('consulta_dnprcResult').get('bico').get('bi').get('dt').get('locs').get('lous').get('lourb').get('dir').get('nv')}"
-                        self.numero = info_cadastre.get('consulta_dnprcResult').get('bico').get('bi').get('dt').get('locs').get('lous').get('lourb').get('dir').get('pnp')
-                        self.antiguedad = info_cadastre.get('consulta_dnprcResult').get('bico').get('bi').get('debi').get('ant')
-                        self.uso = info_cadastre.get('consulta_dnprcResult').get('bico').get('bi').get('debi').get('luso')
-                    elif self.tipo == 'Rústico':
-                        self.parcela = info_cadastre.get('consulta_dnprcResult').get('bico').get('bi').get('dt').get('locs').get('lors').get('lorus').get('cpp').get('cpa')
-                        self.poligono = info_cadastre.get('consulta_dnprcResult').get('bico').get('bi').get('dt').get('locs').get('lors').get('lorus').get('cpp').get('cpo')
-                        self.nombre_paraje = info_cadastre.get('consulta_dnprcResult').get('bico').get('bi').get('dt').get('locs').get('lors').get('lorus').get('npa')
-                    
-                    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")
+        if self._comprobar_errores_catastro(info_cadastre):
+            cudnp = self._obtener_numero_parcelas(info_cadastre, 'dnprc')
+         
+            if cudnp > 1:
+                raise ErrorServidorCatastro(mensaje="Esta parcela tiene varias referencias catastrales. Usa un objeto MetaParcela.")
+            else:
+                self.rc = self._extraer_rc_from_dict(info_cadastre.get('consulta_dnprcResult').get('bico').get('bi').get('idbi').get('rc'))
+                self.url_croquis = requests.get(URL_BASE_CROQUIS_DATOS, params={'refcat': self.rc}).url
+                self.municipio = info_cadastre.get('consulta_dnprcResult').get('bico').get('bi').get('dt').get('nm')
+                self.provincia = info_cadastre.get('consulta_dnprcResult').get('bico').get('bi').get('dt').get('np')
+                self.tipo = 'Rústico' if info_cadastre.get('consulta_dnprcResult').get('bico').get('bi').get('idbi').get('cn') == 'RU' else 'Urbano'
+                if self.tipo == 'Urbano':
+                    self.calle = f"{info_cadastre.get('consulta_dnprcResult').get('bico').get('bi').get('dt').get('locs').get('lous').get('lourb').get('dir').get('tv')} {info_cadastre.get('consulta_dnprcResult').get('bico').get('bi').get('dt').get('locs').get('lous').get('lourb').get('dir').get('nv')}"
+                    self.numero = info_cadastre.get('consulta_dnprcResult').get('bico').get('bi').get('dt').get('locs').get('lous').get('lourb').get('dir').get('pnp')
+                    self.antiguedad = info_cadastre.get('consulta_dnprcResult').get('bico').get('bi').get('debi').get('ant')
+                    self.uso = info_cadastre.get('consulta_dnprcResult').get('bico').get('bi').get('debi').get('luso')
+                elif self.tipo == 'Rústico':
+                    self.parcela = info_cadastre.get('consulta_dnprcResult').get('bico').get('bi').get('dt').get('locs').get('lors').get('lorus').get('cpp').get('cpa')
+                    self.poligono = info_cadastre.get('consulta_dnprcResult').get('bico').get('bi').get('dt').get('locs').get('lors').get('lorus').get('cpp').get('cpo')
+                    self.nombre_paraje = info_cadastre.get('consulta_dnprcResult').get('bico').get('bi').get('dt').get('locs').get('lors').get('lorus').get('npa')
+                
+                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)
+    
     def __create_from_parcel(self, provincia: Union[str,None], municipio: Union[str,None], poligono: Union[str,None], parcela: Union[str,None], projection: str):
         """Create an instance of InfoCatastral from a parcela string."""
-        req = requests.get(f'{URL_BASE_CALLEJERO}/Consulta_DNPPP',
-                           params={
-                               'Provincia': provincia,
-                               'Municipio': municipio,
-                               'Poligono': poligono,
-                               'Parcela': parcela
-                           })
-        if len(req.content) > 0:
-            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)
+        params = self._parametrizar_peticion(
+            Provincia=provincia,
+            Municipio=municipio,
+            Poligono=poligono,
+            Parcela=parcela
+        )
+        response = self._llamar_a_api(f'{URL_BASE_CALLEJERO}/Consulta_DNPPP', params)
+        info_cadastre = self._parsear_respuesta(response)
+        
+        if self._comprobar_errores_catastro(info_cadastre):
+            cudnp = self._obtener_numero_parcelas(info_cadastre, 'dnppp')
 
-                if cudnp > 1:
-                    raise ErrorServidorCatastro(mensaje="Esta parcela tiene varias referencias catastrales. Usa un objeto MetaParcela.")
-                else:
-                    self.rc = ''.join(info_cadastre.get('consulta_dnpppResult').get('bico').get('bi').get('idbi').get('rc').values())
-                    self.__create_from_rc(self.rc, projection)
-        else:
-            raise ErrorServidorCatastro("El servidor ha devuelto una respuesta vacia")
+            if cudnp > 1:
+                raise ErrorServidorCatastro(mensaje="Esta parcela tiene varias referencias catastrales. Usa un objeto MetaParcela.")
+            else:
+                self.rc = self._extraer_rc_from_dict(info_cadastre.get('consulta_dnpppResult').get('bico').get('bi').get('idbi').get('rc'))
+                self.__create_from_rc(self.rc, projection)
 
     def __create_from_address(self, provincia: Union[str,None], municipio: Union[str,None], tipo_via: Union[str,None], calle: Union[str,None], numero: Union[str,None], projection: str):
         """Create an instance of InfoCatastral from an address string."""
@@ -169,37 +265,31 @@ class ParcelaCatastral:
         )
 
         if info_calle:
-            req = requests.get(f'{URL_BASE_CALLEJERO}/Consulta_DNPLOC',
-                               params={
-                                   'Provincia': info_calle.municipio.provincia,
-                                   'Municipio': info_calle.municipio.municipio,
-                                   'Sigla': info_calle.tipo_via,
-                                   'Calle': info_calle.calle,
-                                   'Numero': numero
-                               })
-            
-            if req.status_code == 200 and len(req.content) > 0 and comprobar_errores(req.json()):
-                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)
+            params = self._parametrizar_peticion(
+                Provincia=info_calle.municipio.provincia,
+                Municipio=info_calle.municipio.municipio,
+                Sigla=info_calle.tipo_via,
+                Calle=info_calle.calle,
+                Numero=numero
+            )
+            response = self._llamar_a_api(f'{URL_BASE_CALLEJERO}/Consulta_DNPLOC', params)
+            info_cadastre = self._parsear_respuesta(response)
+             
+            if self._comprobar_errores_catastro(info_cadastre):
+                cudnp = self._obtener_numero_parcelas(info_cadastre, 'dnploc')
 
                 if cudnp > 1:
                     raise ErrorServidorCatastro(mensaje="Esta parcela tiene varias referencias catastrales. Usa un objeto MetaParcela.")
                 else:
                     if 'lrcdnp' in info_cadastre.get('consulta_dnplocResult'):
-                        self.rc = ''.join(info_cadastre.get('consulta_dnplocResult').get('lrcdnp').get('rcdnp')[0].get('rc').values())
+                        self.rc = self._extraer_rc_from_dict(info_cadastre.get('consulta_dnplocResult').get('lrcdnp').get('rcdnp')[0].get('rc'))
                     elif 'bico' in info_cadastre.get('consulta_dnplocResult'):
-                        self.rc = ''.join(info_cadastre.get('consulta_dnplocResult').get('bico').get('bi').get('idbi').get('rc').values())
+                        self.rc = self._extraer_rc_from_dict(info_cadastre.get('consulta_dnplocResult').get('bico').get('bi').get('idbi').get('rc'))
                     self.__create_from_rc(self.rc, projection)
-            elif 'lerr' in json.loads(req.content).get('consulta_dnplocResult') and json.loads(req.content)['consulta_dnplocResult']['lerr'][0]['cod'] == '43':
-                info_cadastre = json.loads(req.content)
+            elif 'lerr' in info_cadastre.get('consulta_dnplocResult') and info_cadastre['consulta_dnplocResult']['lerr'][0]['cod'] == '43':
                 raise Exception(f"Ese número no existe. Prueba con alguno de estos: {[num.get('num').get('pnp') for num in info_cadastre.get('consulta_dnplocResult').get('numerero').get('nump')]}")
             else:
                 raise ErrorServidorCatastro("El servidor ha devuelto una respuesta vacia")
-
-                
         else:
             raise Exception('La calle no existe.')
 
@@ -225,9 +315,11 @@ class ParcelaCatastral:
             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.
+    def distancias_aristas(self) -> Optional[List[float]]:
+        """Calcula las distancias entre puntos consecutivos de la geometría de la parcela.
+        
+        Returns:
+            Lista de distancias entre aristas consecutivas en metros, o None si no hay geometría.
         """
         if self.geometria:
             distancias = []
@@ -243,9 +335,11 @@ class ParcelaCatastral:
             return None
 
     @property
-    def perimetro(self):
-        """
-            Calcula el perímetro de la geometría
+    def perimetro(self) -> Optional[float]:
+        """Calcula el perímetro total de la geometría de la parcela.
+        
+        Returns:
+            Perímetro total en metros, o None si no hay geometría.
         """
         distancias = self.distancias_aristas
         if distancias:
@@ -253,19 +347,27 @@ class ParcelaCatastral:
         else: 
             return None
 
-    def valor_catastral_urbano_m2(self, anio):
+    def valor_catastral_urbano_m2(self, anio: int) -> Optional[float]:
+        """Obtiene el valor catastral por metro cuadrado para parcelas urbanas.
+        
+        Args:
+            anio: Año del valor catastral a consultar.
+            
+        Returns:
+            Valor catastral en €/m², 0 si es rústica, o None si hay algún error.
+        """
         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"
-                               })
+        params = self._parametrizar_peticion(
+            huso="4326",
+            x=self.centroide['x'],
+            y=self.centroide['y'],
+            anyoZV=anio,
+            suelo="N",
+            tipo_mapa="vivienda"
+        )
+        req = self._llamar_a_api(f'{URL_BASE_MAPA_VALORES_URBANOS}', params)
 
         values_map = converters.gpd.read_file(req.content)
         centroide_point = Point(self.centroide['x'],self.centroide['y'])
@@ -274,36 +376,15 @@ class ParcelaCatastral:
         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
-            }
+    def numero_plantas(self) -> Dict[str, Any]:
+        """Obtiene el número de plantas de un edificio a partir de su referencia catastral.
+        
+        Returns:
+            Diccionario con:
+                - 'plantas': Máximo número de plantas sobre rasante (o None)
+                - 'sotanos': Máximo número de plantas bajo rasante
+                - 'total': Suma de plantas sobre y bajo rasante (o None)
         """
-
         if self.tipo == 'Rústico':
             return 0
 
@@ -355,7 +436,6 @@ class ParcelaCatastral:
             })
 
         return {
-            "partes": parts_detail,
             "plantas": max(above_floors) if above_floors else None,
             "sotanos": max(below_floors) if below_floors else 0,
             "total": (
@@ -489,7 +569,7 @@ class ParcelaCatastral:
         """
         converters.to_parquet([self], filename)
         
-class MetaParcela:
+class MetaParcela(ParcelaHelper):
     """
     Clase que representa una MetaParcela, es decir, una gran parcela catastral con 
     varias referencias catastrales (Parcelas Catastrales más pequeñas).
@@ -510,45 +590,71 @@ class MetaParcela:
 
     """
 
-    def __create_from_rc(self, rc: str):
-        """Create an instance of InfoCatastral from a RC (Referencia Catastral) string."""
-        req1 = requests.get(f'{URL_BASE_CALLEJERO}/Consulta_DNPRC',
-                            params={'RefCat': rc})
-
-        if len(req1.content) > 0:
-            info_cadastre = json.loads(req1.content)
-            if comprobar_errores(info_cadastre):
-                self.parcelas = []
-                num_parcelas = info_cadastre.get("consulta_dnprcResult", {}).get("control", {}).get("cudnp", 1)
-                for idx in range(num_parcelas):
-                    rc = ''.join(info_cadastre.get('consulta_dnprcResult').get('lrcdnp').get('rcdnp')[idx].get('rc').values())
+    def __create_from_rc(self, rc: str) -> None:
+        """Create an instance of MetaParcela from a RC (Referencia Catastral) string.
+        
+        Args:
+            rc: Referencia catastral de la metaparcela
+            
+        Raises:
+            ErrorServidorCatastro: Si el servidor devuelve una respuesta vacía o error
+        """
+        params = self._parametrizar_peticion(RefCat=rc)
+        response = self._llamar_a_api(f'{URL_BASE_CALLEJERO}/Consulta_DNPRC', params)
+        info_cadastre = self._parsear_respuesta(response)
+        
+        if self._comprobar_errores_catastro(info_cadastre):
+            self.parcelas = []
+            num_parcelas = self._obtener_numero_parcelas(info_cadastre, 'dnprc')
+            for idx in range(num_parcelas):
+                rc_dict = info_cadastre.get('consulta_dnprcResult').get('lrcdnp').get('rcdnp')[idx].get('rc')
+                rc = self._extraer_rc_from_dict(rc_dict)
                 self.parcelas.append(ParcelaCatastral(rc=rc))
-        else:
-            raise ErrorServidorCatastro("El servidor ha devuelto una respuesta vacia")
                 
 
-    def __create_from_parcel(self, provincia: Union[str,None], municipio: Union[str,None], poligono: Union[str,None], parcela: Union[str,None]):
-        """Create an instance of InfoCatastral from a parcela string."""
-        req = requests.get(f'{URL_BASE_CALLEJERO}/Consulta_DNPPP',
-                           params={
-                               'Provincia': provincia,
-                               'Municipio': municipio,
-                               'Poligono': poligono,
-                               'Parcela': parcela
-                           })
-        if len(req.content) > 0:
-            info_cadastre = json.loads(req.content)
-            if comprobar_errores(info_cadastre):
-                self.parcelas = []
-                num_parcelas = info_cadastre.get("consulta_dnpppResult", {}).get("control", {}).get("cudnp", 1)
-                for idx in range(num_parcelas):
-                    rc = ''.join(info_cadastre.get('consulta_dnpppResult').get('lrcdnp').get('rcdnp')[idx].get('rc').values())
-                    self.parcelas.append(ParcelaCatastral(rc=rc))
-        else:
-            raise ErrorServidorCatastro("El servidor ha devuelto una respuesta vacia")
+    def __create_from_parcel(self, provincia: Union[str,None], municipio: Union[str,None], poligono: Union[str,None], parcela: Union[str,None]) -> None:
+        """Create an instance of MetaParcela from parcel data.
+        
+        Args:
+            provincia: Provincia donde se encuentra la parcela
+            municipio: Municipio donde se encuentra la parcela
+            poligono: Número de polígono
+            parcela: Número de parcela
+            
+        Raises:
+            ErrorServidorCatastro: Si el servidor devuelve una respuesta vacía o error
+        """
+        params = self._parametrizar_peticion(
+            Provincia=provincia,
+            Municipio=municipio,
+            Poligono=poligono,
+            Parcela=parcela
+        )
+        response = self._llamar_a_api(f'{URL_BASE_CALLEJERO}/Consulta_DNPPP', params)
+        info_cadastre = self._parsear_respuesta(response)
+        
+        if self._comprobar_errores_catastro(info_cadastre):
+            self.parcelas = []
+            num_parcelas = self._obtener_numero_parcelas(info_cadastre, 'dnppp')
+            for idx in range(num_parcelas):
+                rc_dict = info_cadastre.get('consulta_dnpppResult').get('lrcdnp').get('rcdnp')[idx].get('rc')
+                rc = self._extraer_rc_from_dict(rc_dict)
+                self.parcelas.append(ParcelaCatastral(rc=rc))
 
-    def __create_from_address(self, provincia: Union[str,None], municipio: Union[str,None], tipo_via: Union[str,None], calle: Union[str,None], numero: Union[str,None]):
-        """Create an instance of InfoCatastral from an address string."""
+    def __create_from_address(self, provincia: Union[str,None], municipio: Union[str,None], tipo_via: Union[str,None], calle: Union[str,None], numero: Union[str,None]) -> None:
+        """Create an instance of MetaParcela from an address.
+        
+        Args:
+            provincia: Provincia donde se encuentra la dirección
+            municipio: Municipio donde se encuentra la dirección
+            tipo_via: Tipo de vía (calle, avenida, etc.)
+            calle: Nombre de la calle
+            numero: Número de la dirección
+            
+        Raises:
+            ErrorServidorCatastro: Si el servidor devuelve una respuesta vacía o error
+            Exception: Si la calle no existe
+        """
         info_calle = Calle(
             municipio=Municipio(
                 provincia=provincia,
@@ -559,29 +665,27 @@ class MetaParcela:
         )
 
         if info_calle:
-            req = requests.get(f'{URL_BASE_CALLEJERO}/Consulta_DNPLOC',
-                               params={
-                                   'Provincia': info_calle.municipio.provincia,
-                                   'Municipio': info_calle.municipio.municipio,
-                                   'Sigla': info_calle.tipo_via,
-                                   'Calle': info_calle.calle,
-                                   'Numero': numero
-                               })
+            params = self._parametrizar_peticion(
+                Provincia=info_calle.municipio.provincia,
+                Municipio=info_calle.municipio.municipio,
+                Sigla=info_calle.tipo_via,
+                Calle=info_calle.calle,
+                Numero=numero
+            )
+            response = self._llamar_a_api(f'{URL_BASE_CALLEJERO}/Consulta_DNPLOC', params)
+            info_cadastre = self._parsear_respuesta(response)
             
-            if req.status_code == 200 and len(req.content) > 0 and comprobar_errores(req.json()):
-                info_cadastre = json.loads(req.content)
+            if self._comprobar_errores_catastro(info_cadastre):
                 self.parcelas = []
-                num_parcelas = info_cadastre.get("consulta_dnplocResult", {}).get("control", {}).get("cudnp", 1)
+                num_parcelas = self._obtener_numero_parcelas(info_cadastre, 'dnploc')
                 for idx in range(num_parcelas):
-                    rc = ''.join(info_cadastre.get('consulta_dnplocResult').get('lrcdnp').get('rcdnp')[idx].get('rc').values())
+                    rc_dict = info_cadastre.get('consulta_dnplocResult').get('lrcdnp').get('rcdnp')[idx].get('rc')
+                    rc = self._extraer_rc_from_dict(rc_dict)
                     self.parcelas.append(ParcelaCatastral(rc=rc))
-            else:
-                raise ErrorServidorCatastro("El servidor ha devuelto una respuesta vacia")
-                
         else:
             raise Exception('La calle no existe.')
 
-    def __init__(self, rc: Union[str,None] = None, provincia: Union[int,str,None] = None, municipio: Union[int,str,None] = None, poligono: Union[int,None] = None, parcela: Union[int,None] = None, tipo_via: Union[str,None] = None, calle: Union[str,None] = None, numero: Union[str,None] = None):
+    def __init__(self, rc: Union[str,None] = None, provincia: Union[int,str,None] = None, municipio: Union[int,str,None] = None, poligono: Union[int,None] = None, parcela: Union[int,None] = None, tipo_via: Union[str,None] = None, calle: Union[str,None] = None, numero: Union[str,None] = None) -> None:
         if rc:
             self.rc = rc
             self.__create_from_rc(rc)
@@ -602,8 +706,7 @@ class MetaParcela:
         
 
     def to_dataframe(self):
-        """
-        Convierte la MetaParcela en un DataFrame de pandas.
+        """Convierte la MetaParcela en un DataFrame de pandas.
 
         Returns:
             pd.DataFrame: Un DataFrame que contiene las parcelas de la MetaParcela.
@@ -611,11 +714,10 @@ class MetaParcela:
         return converters.to_geodataframe(self.parcelas)
     
     def to_json(self, filename: Union[str,None] = None) -> str:
-        """
-        Convierte la MetaParcela en un JSON.
+        """Convierte la MetaParcela en un JSON.
 
         Args:
-            filename (Union[str,None], optional): Nombre del archivo donde guardar el JSON. Defaults to None.
+            filename: Nombre del archivo donde guardar el JSON. Defaults to None.
 
         Returns:
             str: Una cadena JSON que contiene las parcelas de la MetaParcela.
@@ -623,32 +725,29 @@ class MetaParcela:
         return converters.to_json(self.parcelas, filename)
     
     def to_csv(self, filename: Union[str,None] = None) -> str:
-        """
-        Convierte la MetaParcela en un CSV.
+        """Convierte la MetaParcela en un CSV.
 
         Args:
-            filename (Union[str,None], optional): Nombre del archivo donde guardar el CSV. Defaults to None.
+            filename: Nombre del archivo donde guardar el CSV. Defaults to None.
 
         Returns:
             str: Una cadena CSV que contiene las parcelas de la MetaParcela.
         """
         return converters.to_csv(self.parcelas, filename)
     
-    def to_shapefile(self, filename: str):
-        """
-        Guarda la MetaParcela como un archivo Shapefile.
+    def to_shapefile(self, filename: str) -> None:
+        """Guarda la MetaParcela como un archivo Shapefile.
 
         Args:
-            filename (str): El nombre del archivo Shapefile a guardar.
+            filename: El nombre del archivo Shapefile a guardar.
         """
         converters.to_shapefile(self.parcelas, filename)
 
-    def to_parquet(self, filename: str):
-        """
-        Guarda la MetaParcela como un archivo Parquet.
+    def to_parquet(self, filename: str) -> None:
+        """Guarda la MetaParcela como un archivo Parquet.
 
         Args:
-            filename (str): El nombre del archivo Parquet a guardar.
+            filename: El nombre del archivo Parquet a guardar.
         """
         converters.to_parquet(self.parcelas, filename)
         

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ESCatastroLib
-Version: 0.0.1rc5
+Version: 1.0.0
 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
@@ -17,12 +17,14 @@ Classifier: Operating System :: OS Independent
 Classifier: Programming Language :: Python :: 3
 Classifier: Topic :: Software Development :: Build Tools
 Requires-Dist: folium
-Requires-Dist: geopandas
+Requires-Dist: geopandas<0.14; python_version < '3.9'
+Requires-Dist: geopandas>=0.14; python_version >= '3.9'
 Requires-Dist: geopy
-Requires-Dist: pyarrow
-Requires-Dist: pytest
+Requires-Dist: pyarrow<14; python_version < '3.9'
+Requires-Dist: pyarrow>=14; python_version >= '3.9'
 Requires-Dist: requests
-Requires-Dist: shapely
+Requires-Dist: shapely<2; python_version < '3.9'
+Requires-Dist: shapely>=2; python_version >= '3.9'
 Requires-Dist: xmltodict
 Description-Content-Type: text/markdown
 
@@ -116,6 +118,34 @@ referencia a una MetaParcela.
 * `regiones (list)`: Una lista de regiones en la parcela con una descripción y superficie.
 * `centroide (dict)`:  Las coordenadas del centroide de la parcela. (Latitud y longitud)
 * `geometria (list)`:  Una lista de puntos que representan la geometría de la parcela. (Latitud y longitud)
+* `superficie_total (float)`:  La superficie total de la parcela en metros cuadrados.
+* `superficie_construida (float)`:  La superficie construida en metros cuadrados.
+* `superficie (float)`:  La superficie total de las regiones en metros cuadrados.
+
+**Métodos:**
+
+* `distancias_aristas` (property): Calcula las distancias entre puntos consecutivos de la geometría de la parcela.
+  * Returns: `Optional[List[float]]` - Lista de distancias entre aristas consecutivas en metros, o None si no hay geometría.
+
+* `perimetro` (property): Calcula el perímetro total de la geometría de la parcela.
+  * Returns: `Optional[float]` - Perímetro total en metros, o None si no hay geometría.
+
+* `valor_catastral_urbano_m2(anio: int) -> Optional[float]`: Obtiene el valor catastral por metro cuadrado para parcelas urbanas.
+  * Args: `anio` (int) - Año del valor catastral a consultar.
+  * Returns: Valor catastral en €/m², 0 si es rústica, o None si hay algún error.
+
+* `valor_catastral_rustico_m2(anio: str) -> Optional[Dict]`: Obtiene los valores catastrales de tierras para parcelas rústicas.
+  * Args: `anio` (str) - Año del valor catastral a consultar.
+  * Returns: Diccionario con `region`, `nombre_region` y `modulos_€/ha`, o None si no se encuentran.
+
+* `numero_plantas` (property): Obtiene el número de plantas de un edificio.
+  * Returns: `Dict[str, Any]` con claves `plantas`, `sotanos` y `total`.
+
+* `to_dataframe()`: Convierte la parcela en un GeoDataFrame de GeoPandas.
+* `to_json(filename: Optional[str] = None) -> str`: Convierte la parcela a JSON.
+* `to_csv(filename: Optional[str] = None) -> str`: Convierte la parcela a CSV.
+* `to_shapefile(filename: str)`: Guarda la parcela como Shapefile.
+* `to_parquet(filename: str)`: Guarda la parcela como Parquet.
 
 
 ## Clase MetaParcela

{escatastrolib-0.0.1rc5.dist-info → escatastrolib-1.0.0.dist-info}/RECORD

@@ -1,17 +1,15 @@
-ESCatastroLib/__about__.py,sha256=4Gd4-yBRspaqdiFVWu4WyG_F7tAMkrybx_WdUxj5x1U,131
+ESCatastroLib/__about__.py,sha256=buISjIv39OyjZ4jasw7ncClX_p6X5LIUq6vQCYP8qqc,128
 ESCatastroLib/__init__.py,sha256=QCXZ5qTCAGhkZr63i0Y7zZpkLKd342edUzjt9U_Ujqs,220
 ESCatastroLib/models/Calle.py,sha256=TfgJfRiCSl6Fgug2--Wo2x5cj6JQdhHQojtZDZOgVSo,2846
-ESCatastroLib/models/InfoCatastral.py,sha256=IJGrx0QAtfPSeXDss24lSorGMsyfwiWu6S2PChqCyY0,31362
+ESCatastroLib/models/InfoCatastral.py,sha256=szmAdCmFS_J2-IgBv5UuowAGwAPF5xhuKoRddNYv8xA,34485
 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-1.0.0.dist-info/METADATA,sha256=0ye6_LUFEsuTXaazqyeFRyv3LUxCPbLX8aKnA-MciuA,20050
+escatastrolib-1.0.0.dist-info/WHEEL,sha256=aha0VrrYvgDJ3Xxl3db_g_MDIW-ZexDdrc_m-Hk8YY4,105
+escatastrolib-1.0.0.dist-info/licenses/LICENSE,sha256=kgDY5GRu9WGoKk_0F0iYmXuLmGiZ9hgtReHhCfJBWr8,11319
+escatastrolib-1.0.0.dist-info/RECORD,,

{escatastrolib-0.0.1rc5.dist-info → escatastrolib-1.0.0.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: hatchling 1.27.0
+Generator: hatchling 1.28.0
 Root-Is-Purelib: true
 Tag: py2-none-any
 Tag: py3-none-any

ESCatastroLib/utils/test_plantas.py

@@ -1,109 +0,0 @@
-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

@@ -1,136 +0,0 @@
-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.")