ESCatastroLib 0.0.1rc5__tar.gz → 1.0.0__tar.gz

escatastrolib-0.0.1rc5/README.md → escatastrolib-1.0.0/PKG-INFO

@@ -1,3 +1,33 @@
+Metadata-Version: 2.4
+Name: ESCatastroLib
+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
+Project-URL: Source, https://github.com/IvanitiX/ESCatastroLib
+Author-email: "Iván V.R" <IvanVR@protonmail.com>
+License: Apache License (2.0)
+License-File: LICENSE
+Keywords: catastro,espana,gis,spain
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Natural Language :: Spanish
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Software Development :: Build Tools
+Requires-Dist: folium
+Requires-Dist: geopandas<0.14; python_version < '3.9'
+Requires-Dist: geopandas>=0.14; python_version >= '3.9'
+Requires-Dist: geopy
+Requires-Dist: pyarrow<14; python_version < '3.9'
+Requires-Dist: pyarrow>=14; python_version >= '3.9'
+Requires-Dist: requests
+Requires-Dist: shapely<2; python_version < '3.9'
+Requires-Dist: shapely>=2; python_version >= '3.9'
+Requires-Dist: xmltodict
+Description-Content-Type: text/markdown
+
 # ESCatastroLib
 
 La librería ESCatastroLib proporciona una interfaz sencilla para consultar el Catastro de España y obtener información geográfica precisa. Con esta librería, puedes acceder a datos como la ubicación de parcelas, características de construcción y valores geográficos.
@@ -88,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/PKG-INFO → escatastrolib-1.0.0/README.md

@@ -1,31 +1,3 @@
-Metadata-Version: 2.4
-Name: ESCatastroLib
-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
-Project-URL: Source, https://github.com/IvanitiX/ESCatastroLib
-Author-email: "Iván V.R" <IvanVR@protonmail.com>
-License: Apache License (2.0)
-License-File: LICENSE
-Keywords: catastro,espana,gis,spain
-Classifier: Development Status :: 3 - Alpha
-Classifier: Intended Audience :: Developers
-Classifier: License :: OSI Approved :: Apache Software License
-Classifier: Natural Language :: Spanish
-Classifier: Operating System :: OS Independent
-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
-Requires-Dist: shapely
-Requires-Dist: xmltodict
-Description-Content-Type: text/markdown
-
 # ESCatastroLib
 
 La librería ESCatastroLib proporciona una interfaz sencilla para consultar el Catastro de España y obtener información geográfica precisa. Con esta librería, puedes acceder a datos como la ubicación de parcelas, características de construcción y valores geográficos.
@@ -116,6 +88,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-1.0.0/TODO_Python314_Compatibility.md

@@ -0,0 +1,40 @@
+# TODO: Python 3.8-3.14 Compatibility Update
+
+## Objective
+Update the ESCatastroLib library to be compatible with Python versions 3.8 through 3.14.
+
+## Tasks
+
+### 1. Update pyproject.toml
+- [x] Add "3.14" to the test matrix under `[tool.hatch.envs.test.matrix]`
+- [ ] Ensure all dependencies support Python 3.8-3.14 range
+
+### 2. Code Review and Updates
+- [x] Review `src/escatastrolib/models/InfoCatastral.py` for deprecated patterns
+- [x] Review `src/escatastrolib/utils/utils.py` for deprecated patterns
+- [x] Check for any `list(dict.values())[0]` patterns that may need updating
+- [x] Verify `typing` imports are compatible with all Python versions
+
+### 3. Testing
+- [x] Verify the library can be imported successfully
+- [x] Run existing tests to ensure compatibility
+- [x] Check for any deprecation warnings
+
+### 4. Documentation
+- [ ] Update README.md if needed
+- [ ] Verify classifiers in pyproject.toml are accurate
+
+## Notes
+- Must maintain backward compatibility with Python 3.8
+- Python 3.14 may have stricter type checking and deprecation warnings
+- Some patterns may work but trigger deprecation warnings
+
+## Progress
+- [x] Analyzed codebase structure
+- [x] Reviewed pyproject.toml configuration
+- [x] Reviewed main source files for potential compatibility issues
+- [x] Implemented updates for Python 3.14 compatibility
+- [x] Updated pyproject.toml to include Python 3.14 in test matrix
+- [x] Verified library imports successfully
+- [x] Ran tests to verify compatibility
+

escatastrolib-1.0.0/TODO_Refactorizacion.md

@@ -0,0 +1,34 @@
+# TODO: Refactorización de InfoCatastral.py
+
+## Objetivo
+Refactorizar el archivo `src/escatastrolib/models/InfoCatastral.py` para mejorar:
+- Eliminación de código duplicado entre `ParcelaCatastral` y `MetaParcela`
+- Mejor manejo de errores
+- Type hints en todos los métodos
+- Docstrings mejorados
+
+## Cambios de Nomenclatura
+- `BaseParcela` → `ParcelaHelper`
+- `_make_api_request` → `_llamar_a_api`
+
+## Estado Actual (Actualizado: 2024)
+- ✅ Fase 1: Extracción de funcionalidades comunes - COMPLETADA
+- ✅ Fase 2: Refactorización de ParcelaCatastral - COMPLETADA
+- ✅ Fase 3: Refactorización de MetaParcela - COMPLETADA
+- ✅ Fase 4: Validación - COMPLETADA (10 tests pasan)
+- ✅ Fase 5: Type Hints y Docstrings Faltantes - COMPLETADA
+  - ✅ `__create_regions()` - type hints y docstring agregados
+  - ✅ `__create_geometry()` - type hints y docstring agregados, usa `_llamar_a_api()`
+  - ✅ `distancias_aristas` - type hints agregados (`Optional[List[float]]`)
+  - ✅ `perimetro` - type hints agregados (`Optional[float]`)
+  - ✅ `valor_catastral_urbano_m2()` - type hints agregados, usa `_llamar_a_api()`
+  - ✅ `numero_plantas` - type hints y docstring mejorados
+  - ✅ `valor_catastral_rustico_m2()` - type hints en parámetro
+
+## Tests
+- ✅ Todos los 10 tests pasan sin regresiones
+
+## Notas
+- Mantener compatibilidad con la API existente
+- No cambiar la firma pública de los métodos
+

{escatastrolib-0.0.1rc5 → escatastrolib-1.0.0}/pyproject.toml

@@ -21,15 +21,25 @@ classifiers = [
     "Operating System :: OS Independent",
     "Natural Language :: Spanish"
 ]
+
 dependencies = [
-    "geopandas",
-    "shapely",
-    "pyarrow",
-    "pytest",
-    "requests",
-    "xmltodict",
-    "folium",
-    "geopy"
+  # comunes (siempre)
+  "requests",
+  "xmltodict",
+  "folium",
+  "geopy",
+
+  # --- shapely ---
+  "shapely<2; python_version<'3.9'",
+  "shapely>=2; python_version>='3.9'",
+
+  # --- geopandas ---
+  "geopandas<0.14; python_version<'3.9'",
+  "geopandas>=0.14; python_version>='3.9'",
+
+  # --- pyarrow ---
+  "pyarrow<14; python_version<'3.9'",
+  "pyarrow>=14; python_version>='3.9'",
 ]
 
 
@@ -45,11 +55,17 @@ path = "src/escatastrolib/__about__.py"
 extra-dependencies = [
   "mypy>=1.0.0",
 ]
+
 [tool.hatch.envs.types.scripts]
 check = "mypy --install-types --non-interactive {args:src/escatastrolib tests}"
 
-[[tool.hatch.envs.test.matrix]]
-python = ["3.8", "3.9", "3.10", "3.11", "3.12", "3.13"]
+[tool.hatch.envs.hatch-test]
+dependencies = [
+  "pytest",
+]
+
+[[tool.hatch.envs.hatch-test.matrix]]
+python = ["3.8", "3.9", "3.10", "3.11", "3.12", "3.13", "3.14"]
 
 [tool.coverage.run]
 source_pkgs = ["escatastrolib", "tests"]

{escatastrolib-0.0.1rc5 → escatastrolib-1.0.0}/src/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-0.0.1rc5 → escatastrolib-1.0.0}/src/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/src/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-0.0.1rc5/src/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.")