ESCatastroLib 0.0.1rc0__tar.gz

escatastrolib-0.0.1rc0/ESCatastroLib/__init__.py

@@ -0,0 +1,3 @@
+# ESCatastroLib/__init__.py
+from .models import Calle, Municipio, ParcelaCatastral, MetaParcela
+from .utils import exceptions, statics, utils

escatastrolib-0.0.1rc0/ESCatastroLib/models/Calle.py

@@ -0,0 +1,49 @@
+from .Municipio import Municipio
+from ..utils.statics import URL_BASE_CALLEJERO
+from ..utils.utils import comprobar_errores
+
+import requests
+import json
+
+class Calle:
+    """
+    Clase que representa una calle.
+    Args:
+        municipio (Municipio): Objeto que representa el municipio al que pertenece la calle.
+        nombre_calle (str, optional): Nombre de la calle. Default es None.
+        tipo_via (str, optional): Tipo de vía de la calle. Default es None.
+    Raises:
+        Exception: Se produce cuando ocurre un error al asignar la calle.
+        Exception: Se produce cuando no se especifica el nombre de la calle.
+        Exception: Se produce cuando no se encuentran calles disponibles.
+    Attributes:
+        calle (str): Nombre de la calle asignada.
+        tipo_via (str): Tipo de vía de la calle asignada.
+        municipio (Municipio): Objeto que representa el municipio al que pertenece la calle.
+    """
+
+    def __init__(self, municipio: Municipio, nombre_calle: str|None = None, tipo_via: str|None = None):
+        uri = f'{URL_BASE_CALLEJERO}/ObtenerCallejero'
+
+        request = requests.get(uri, params={
+            'Provincia': municipio.provincia,
+            'Municipio': municipio.municipio,
+            'NomVia': nombre_calle,
+            'TipoVia': tipo_via
+        })
+
+        if request.status_code == 200:
+            calle_dict = json.loads(request.text)
+
+            if comprobar_errores(calle_dict) and nombre_calle:
+                if len(calle_dict.get('consulta_callejeroResult').get('callejero').get('calle')) == 1:
+                    self.calle = calle_dict.get('consulta_callejeroResult').get('callejero').get('calle')[0].get('dir').get('nv')
+                    self.tipo_via = calle_dict.get('consulta_callejeroResult').get('callejero').get('calle')[0].get('dir').get('tv')
+                    self.municipio = municipio
+                else:
+                    raise Exception(f"""Error al asignar calle. No has especificado la calle completamente, o ese nombre está en varios lados (indica el tipo de vía que aparezca al principio de la vía como PZ o CL). Estas son las calles disponibles con esa búsqueda: {','.join(f"{cl.get('dir').get('tv')} {cl.get('dir').get('nv')}" for cl in calle_dict.get('consulta_callejeroResult').get('callejero').get('calle'))}""")
+            else:
+                raise Exception(f"""Error al asignar calle. No has especificado la calle. Estas son las calles disponibles: {','.join(f"{cl.get('dir').get('tv')} {cl.get('dir').get('nv')}" for cl in calle_dict.get('consulta_callejeroResult').get('callejero').get('calle'))}""")
+            
+        else:
+            raise Exception(f'Error al listar calles: Puede que no exista ese municipio.')

escatastrolib-0.0.1rc0/ESCatastroLib/models/InfoCatastral.py

@@ -0,0 +1,303 @@
+import requests
+import json
+import xmltodict
+
+from ..utils.statics import URL_BASE_CALLEJERO, URL_BASE_GEOGRAFIA, URL_BASE_CROQUIS_DATOS
+from ..utils.utils import comprobar_errores
+from ..utils.exceptions import ErrorServidorCatastro
+from .Calle import Calle, Municipio
+
+class ParcelaCatastral:
+    """
+    Clase que representa una parcela catastral.
+    Args:
+        rc (str, optional): La referencia catastral de la parcela. Defaults to None. Puede ir solo.
+
+        provincia (int|str, optional): El código o nombre de la provincia. Defaults to None. Se usa para buscar por dirección o parcela.
+        municipio (int|str, optional): El código o nombre del municipio. Defaults to None. Se usa para buscar por dirección o parcela.
+        poligono (int, optional): El número del polígono. Defaults to None. Se usa para buscar por parcela.
+        parcela (int, optional): El número de la parcela. Defaults to None. Se usa para buscar por parcela.
+        tipo_via (str, optional): El tipo de vía de la dirección. Defaults to None. Se usa para buscar por dirección.
+        calle (str, optional): El nombre de la calle de la dirección. Defaults to None. Se usa para buscar por dirección.
+        numero (str, optional): El número de la dirección. Defaults to None. Se usa para buscar por dirección.
+    Raises:
+        ValueError: Se lanza si no se proporciona suficiente información para realizar la búsqueda o si la RC corresponde a una MetaParcela.
+        ErrorServidorCatastro: Se lanza si hay un error en el servidor del Catastro.
+    Attributes:
+        rc (str): La referencia catastral de la parcela.
+        provincia (int|str): El código o nombre de la provincia.
+        municipio (int|str): El código o nombre del municipio.
+        poligono (int): El número del polígono. Sólo se da en terrenos Rústicos.
+        parcela (int): El número de la parcela. Sólo se da en terrenos Rústicos.
+        tipo_via (str): El tipo de vía de la dirección. Sólo se da en terrenos Urbanos.
+        calle (str): El nombre de la calle de la dirección. Sólo se da en terrenos Urbanos.
+        numero (str): El número de la dirección. Sólo se da en terrenos Urbanos.
+        url_croquis (str): La URL del croquis de la parcela.
+        tipo (str): El tipo de la parcela (Urbano o Rústico).
+        antiguedad (str): La antigüedad de la parcela (solo para parcelas urbanas).
+        uso (str): El uso de la parcela (solo para parcelas urbanas).
+        nombre_paraje (str): El nombre del paraje (solo para parcelas rústicas).
+        regiones (list): Una lista de regiones de la parcela, cada una con una descripción y superficie.
+        geocentro (dict): Las coordenadas del geocentro de la parcela.
+        geometria (list): Una lista de puntos que representan la geometría de la parcela.
+    """
+
+    def __create_regions(self, info_cadastre: dict):
+        self.regiones = []
+        if self.tipo == 'Urbano':
+            iterator = list(info_cadastre.values())[0].get('bico').get('lcons')
+        elif self.tipo == 'Rústico':
+            iterator = list(info_cadastre.values())[0].get('bico').get('lspr')
+        for region in iterator:
+            if self.tipo == 'Rústico':
+                self.regiones.append({
+                        'descripcion': region.get('dspr').get('dcc'),
+                        'superficie': region.get('dspr').get('ssp')
+                    })
+            elif self.tipo == 'Urbano':
+                self.regiones.append({
+                        'descripcion': region.get('lcd'),
+                        'superficie': region.get('dfcons').get('stl')
+                    })
+
+
+    def __create_geometry(self):
+        geometry_request = requests.get(f'{URL_BASE_GEOGRAFIA}',
+                                        params={
+                                            'service':'wfs',
+                                            'version':'2',
+                                            'request':'getfeature',
+                                            'STOREDQUERIE_ID':'GetParcel',
+                                            'refcat': self.rc,
+                                            'srsname': 'EPSG:4326'
+                                        })
+
+        geometry = xmltodict.parse(geometry_request.content)
+        geoposition = geometry.get('FeatureCollection').get('member').get('cp:CadastralParcel').get('cp:referencePoint').get('gml:Point').get('gml:pos').split(' ')
+        self.geocentro = {
+            'x': geoposition[0],
+            'y': geoposition[1]
+        }
+        parcel_geometry = geometry.get('FeatureCollection').get('member').get('cp:CadastralParcel').get('cp:geometry').get('gml:MultiSurface').get('gml:surfaceMember').get('gml:Surface').get('gml:patches').get('gml:PolygonPatch').get('gml:exterior').get('gml:LinearRing').get('gml:posList').get('#text').split(' ')
+        self.geometria = [
+            {
+                'x': parcel_geometry[2*idx],
+                'y': parcel_geometry[2*idx+1]
+            } for idx in range(len(parcel_geometry)//2)
+        ]
+
+    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})
+        
+        info_cadastre = json.loads(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.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()
+
+                self.superficie = sum(float(region.get('superficie')) for region in self.regiones)
+
+    def __create_from_parcel(self, provincia: str|None, municipio: str|None, poligono: str|None, parcela: 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
+                           })
+        
+        info_cadastre = json.loads(req.content)
+        if comprobar_errores(info_cadastre):
+            cudnp = info_cadastre.get("consulta_dnpppResult", {}).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_dnpppResult').get('bico').get('bi').get('idbi').get('rc').values())
+                self.__create_from_rc(self.rc)
+
+    def __create_from_address(self, provincia: str|None, municipio: str|None, tipo_via: str|None, calle: str|None, numero: str|None):
+        """Create an instance of InfoCatastral from an address string."""
+        info_calle = Calle(
+            municipio=Municipio(
+                provincia=provincia,
+                municipio=municipio
+            ),
+            tipo_via=tipo_via,
+            nombre_calle=calle
+        )
+
+        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 comprobar_errores(req.json()):
+                info_cadastre = json.loads(req.content)
+                cudnp = info_cadastre.get("consulta_dnplocResult", {}).get("control", {}).get("cudnp", 1)
+
+                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())
+                    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.__create_from_rc(self.rc)
+            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)
+                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 Exception('La calle no existe.')
+
+    def __init__(self, rc: str|None = None, provincia: int|str|None = None, municipio: int|str|None = None, poligono: int|None = None, parcela: int|None = None, tipo_via: str|None = None, calle: str|None = None, numero: str|None = None):
+        if rc:
+            self.rc = rc
+            self.__create_from_rc(rc)
+        elif provincia and municipio and poligono and parcela:
+            self.provincia = provincia
+            self.municipio = municipio
+            self.poligono = poligono
+            self.parcela = parcela
+            self.__create_from_parcel(provincia, municipio, poligono, parcela)
+        elif provincia and municipio and tipo_via and calle and numero:
+            self.provincia = provincia
+            self.municipio = municipio
+            self.calle = calle
+            self.numero = numero
+            self.__create_from_address(provincia, municipio, tipo_via, calle, numero)
+        else:
+            raise ValueError("No se ha proporcionado suficiente información para realizar la búsqueda")
+        
+class MetaParcela:
+    """
+    Clase que representa una MetaParcela, es decir, una gran parcela catastral con 
+    varias referencias catastrales (Parcelas Catastrales más pequeñas).
+
+    Args:
+        rc (str|None): La referencia catastral de la MetaParcela.
+
+        provincia (int|str|None): El nombre de la provincia donde se encuentra la MetaParcela.
+        municipio (int|str|None): El nombre del municipio donde se encuentra la MetaParcela.
+        poligono (int|None): El número de polígono de la MetaParcela. Sólo se usa para buscar por parcela.
+        parcela (int|None): El número de parcela de la MetaParcela. Sólo se usa para buscar por parcela.
+        tipo_via (str|None): El tipo de vía de la dirección de la MetaParcela. Sólo se usa para buscar por dirección.
+        calle (str|None): El nombre de la calle de la dirección de la MetaParcela. Sólo se usa para buscar por dirección.
+        numero (str|None): El número de la dirección de la MetaParcela. Sólo se usa para buscar por dirección.
+    Attributes:
+        rc (str): La referencia catastral de la MetaParcela.
+        parcelas (list): Una lista de ParcelaCatastral que representan las parcelas que componen la 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})
+    
+        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())
+                self.parcelas.append(ParcelaCatastral(rc=rc))
+                
+
+    def __create_from_parcel(self, provincia: str|None, municipio: str|None, poligono: str|None, parcela: 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
+                           })
+        
+        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))
+
+    def __create_from_address(self, provincia: str|None, municipio: str|None, tipo_via: str|None, calle: str|None, numero: str|None):
+        """Create an instance of InfoCatastral from an address string."""
+        info_calle = Calle(
+            municipio=Municipio(
+                provincia=provincia,
+                municipio=municipio
+            ),
+            tipo_via=tipo_via,
+            nombre_calle=calle
+        )
+
+        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 comprobar_errores(req.json()):
+                info_cadastre = json.loads(req.content)
+                self.parcelas = []
+                num_parcelas = info_cadastre.get("consulta_dnplocResult", {}).get("control", {}).get("cudnp", 1)
+                for idx in range(num_parcelas):
+                    rc = ''.join(info_cadastre.get('consulta_dnplocResult').get('lrcdnp').get('rcdnp')[idx].get('rc').values())
+                    self.parcelas.append(ParcelaCatastral(rc=rc))
+                
+        else:
+            raise Exception('La calle no existe.')
+
+    def __init__(self, rc: str|None = None, provincia: int|str|None = None, municipio: int|str|None = None, poligono: int|None = None, parcela: int|None = None, tipo_via: str|None = None, calle: str|None = None, numero: str|None = None):
+        if rc:
+            self.rc = rc
+            self.__create_from_rc(rc)
+        elif provincia and municipio and poligono and parcela:
+            self.provincia = provincia
+            self.municipio = municipio
+            self.poligono = poligono
+            self.parcela = parcela
+            self.__create_from_parcel(provincia, municipio, poligono, parcela)
+        elif provincia and municipio and tipo_via and calle and numero:
+            self.provincia = provincia
+            self.municipio = municipio
+            self.calle = calle
+            self.numero = numero
+            self.__create_from_address(provincia, municipio, tipo_via, calle, numero)
+        else:
+            raise ValueError("No se ha proporcionado suficiente información para realizar la búsqueda")
+        

escatastrolib-0.0.1rc0/ESCatastroLib/models/Municipio.py

@@ -0,0 +1,29 @@
+from ..utils.utils import listar_municipios
+
+class Municipio:
+    """
+    Clase que representa un municipio.
+    Args:
+        provincia (str): El nombre de la provincia a la que pertenece el municipio.
+        municipio (str, optional): El nombre del municipio. Si no se proporciona, se lanzará una excepción con el municipio.
+    Attributes:
+        provincia (str): El nombre de la provincia a la que pertenece el municipio.
+        municipio (str): El nombre del municipio.
+    Raises:
+        Exception: Si no se especifica el municipio o si el municipio especificado no está disponible o si no se ha especificado completamente (te dará una lista de coincidencias).
+    """
+
+    def __init__(self, provincia: str, municipio: str|None = None):
+        municipios = listar_municipios(provincia=provincia,municipio=municipio)
+
+        if municipio:
+            if len(municipios) == 1:
+                self.provincia = provincia
+                self.municipio = municipios[0]
+            elif municipio.upper() in municipios:
+                self.provincia = provincia
+                self.municipio = municipio.upper()
+            else:
+                raise Exception(f"Error al asignar municipio. No has especificado el municipio completamente. Estos son los municipios disponibles con esa búsqueda: {','.join(municipios)}")
+        else:
+            raise Exception(f"Error al asignar municipio. No has especificado el municipio. Estos son los municipios disponibles: {','.join(municipios)}")

escatastrolib-0.0.1rc0/ESCatastroLib/models/__init__.py

@@ -0,0 +1,4 @@
+# ESCatastroLib/models/__init__.py
+from .Calle import Calle
+from .Municipio import Municipio
+from .InfoCatastral import ParcelaCatastral, MetaParcela

escatastrolib-0.0.1rc0/ESCatastroLib/utils/__init__.py

@@ -0,0 +1,4 @@
+# ESCatastroLib/utils/__init__.py
+from .exceptions import *
+from .statics import *
+from .utils import *

escatastrolib-0.0.1rc0/ESCatastroLib/utils/exceptions.py

@@ -0,0 +1,21 @@
+class ErrorServidorCatastro(Exception):
+    """
+    Clase de excepción personalizada para errores relacionados con el servidor del Catastro.
+    Atributos:
+    - mensaje (str): Mensaje de error específico del servidor del Catastro.
+    """
+
+    def __init__(self, mensaje=''):
+        self.message = f'Error del Catastro. {mensaje}'
+        super().__init__(self.message)
+
+def lanzar_excepcion(mensaje_error: str) -> Exception:
+    """
+    Lanza una excepción personalizada con el mensaje de error proporcionado.
+    Args:
+        mensaje_error (str): El mensaje de error que se incluirá en la excepción.
+    Returns:
+        Exception: La excepción personalizada con el mensaje de error.
+    """
+
+    return ErrorServidorCatastro(mensaje=mensaje_error)

escatastrolib-0.0.1rc0/ESCatastroLib/utils/statics.py

@@ -0,0 +1,122 @@
+URL_BASE_CALLEJERO = 'https://ovc.catastro.meh.es/OVCServWeb/OVCWcfCallejero/COVCCallejero.svc/json'
+URL_BASE_GEOGRAFIA = 'http://ovc.catastro.meh.es/INSPIRE/wfsCP.aspx'
+URL_BASE_CROQUIS_DATOS = f'https://www1.sedecatastro.gob.es/CYCBienInmueble/SECImprimirCroquisYDatos.aspx'
+
+MAPEOS_PROVINCIAS = {
+    'La Coruña': 'A Coruña',
+    'Orense': 'Ourense',
+    'Santa Cruz De Tenerife': 'S.C. Tenerife',
+    'Las Palmas De Gran Canaria': 'Las Palmas',
+    'Alicante': 'Alacant',
+    'Almería': 'Almeria',
+    'Cádiz': 'Cadiz',
+    'Córdoba': 'Cordoba',
+    'Gerona': 'Girona',
+    'Castellón De La Plana': 'Castello',
+    'Castellón': 'Castello',
+    'Lérida': 'Lleida',
+    'Málaga': 'Malaga',
+    'León': 'Leon',
+    'Ávila': 'Avila',
+    'Cáceres': 'Caceres',
+    'Baleares': 'Illes Balears',
+    'Islas Baleares': 'Illes Balears',
+    'Jaén': 'Jaen',
+    'València': 'Valencia'
+}
+
+TIPOS_VIA = {
+    "AC": "ACCESO",
+    "AG": "AGREGADO",
+    "AL": "ALDEA, ALAMEDA",
+    "AN": "ANDADOR",
+    "AR": "AREA, ARRABAL",
+    "AU": "AUTOPISTA",
+    "AV": "AVENIDA",
+    "AY": "ARROYO",
+    "BJ": "BAJADA",
+    "BL": "BLOQUE",
+    "BO": "BARRIO",
+    "BQ": "BARRANQUIL",
+    "BR": "BARRANCO",
+    "CA": "CAÑADA",
+    "CG": "COLEGIO, CIGARRAL",
+    "CH": "CHALET",
+    "CI": "CINTURON",
+    "CJ": "CALLEJA, CALLEJON",
+    "CL": "CALLE",
+    "CM": "CAMINO, CARMEN",
+    "CN": "COLONIA",
+    "CO": "CONCEJO, COLEGIO",
+    "CP": "CAMPA, CAMPO",
+    "CR": "CARRETERA, CARRERA",
+    "CS": "CASERIO",
+    "CT": "CUESTA, COSTANILLA",
+    "CU": "CONJUNTO",
+    "CY": "CALEYA",
+    "CZ": "CALLIZO",
+    "DE": "DETRÁS",
+    "DP": "DIPUTACION",
+    "DS": "DISEMINADOS",
+    "ED": "EDIFICIOS",
+    "EM": "EXTRAMUROS",
+    "EN": "ENTRADA, ENSANCHE",
+    "EP": "ESPALDA",
+    "ER": "EXTRARRADIO",
+    "ES": "ESCALINATA",
+    "EX": "EXPLANADA",
+    "FC": "FERROCARRIL",
+    "FN": "FINCA",
+    "GL": "GLORIETA",
+    "GR": "GRUPO",
+    "GV": "GRAN VIA",
+    "HT": "HUERTA, HUERTO",
+    "JR": "JARDINES",
+    "LA": "LAGO",
+    "LD": "LADO, LADERA",
+    "LG": "LUGAR",
+    "MA": "MALECON",
+    "MC": "MERCADO",
+    "ML": "MUELLE",
+    "MN": "MUNICIPIO",
+    "MS": "MASIAS",
+    "MT": "MONTE",
+    "MZ": "MANZANA",
+    "PB": "POBLADO",
+    "PC": "PLACETA",
+    "PD": "PARTIDA",
+    "PI": "PARTICULAR",
+    "PJ": "PASAJE, PASADIZO",
+    "PL": "POLIGONO",
+    "PM": "PARAMO",
+    "PQ": "PARROQUIA, PARQUE",
+    "PR": "PROLONGACION, CONTINUAC.",
+    "PS": "PASEO",
+    "PT": "PUENTE",
+    "PU": "PASADIZO",
+    "PZ": "PLAZA",
+    "QT": "QUINTA",
+    "RA": "RACONADA",
+    "RB": "RAMBLA",
+    "RC": "RINCON, RINCONA",
+    "RD": "RONDA",
+    "RM": "RAMAL",
+    "RP": "RAMPA",
+    "RR": "RIERA",
+    "RU": "RUA",
+    "SA": "SALIDA",
+    "SC": "SECTOR",
+    "SD": "SENDA",
+    "SL": "SOLAR",
+    "SN": "SALON",
+    "SU": "SUBIDA",
+    "TN": "TERRENOS",
+    "TO": "TORRENTE",
+    "TR": "TRAVESIA",
+    "UR": "URBANIZACION",
+    "VA": "VALLE",
+    "VD": "VIADUCTO",
+    "VI": "VIA",
+    "VL": "VIAL",
+    "VR": "VEREDA"
+}

escatastrolib-0.0.1rc0/ESCatastroLib/utils/utils.py

@@ -0,0 +1,102 @@
+import requests
+import json
+
+from .statics import URL_BASE_CALLEJERO, MAPEOS_PROVINCIAS, TIPOS_VIA
+from .exceptions import lanzar_excepcion
+
+def comprobar_errores(respuesta: dict):
+    """
+    Comprueba si la respuesta contiene errores.
+
+    Args:
+        respuesta (dict): El diccionario de respuesta.
+
+    Raises:
+        lanzar_excepcion: Si se encuentra un error en la respuesta.
+
+    Returns:
+        bool: True si no se encuentran errores, False en caso contrario.
+    """
+    # Check if the response contains the expected structure
+    if len(list(respuesta.values())) > 0:
+        if list(respuesta.values())[0] is not None and 'lerr' in list(respuesta.values())[0].keys():
+            if 'err' in list(respuesta.values())[0]['lerr']:
+                raise lanzar_excepcion(mensaje_error=list(respuesta.values())[0]['lerr']['err'][0]['des'])
+            else:
+                raise lanzar_excepcion(mensaje_error=list(respuesta.values())[0]['lerr'][0]['des'])
+        return True
+
+def listar_provincias():
+    """
+    Obtiene una lista de provincias.
+    Returns:
+        list: Una lista de nombres de provincias.
+    Raises:
+        None
+    """
+    
+    response = requests.get(f'{URL_BASE_CALLEJERO}/ObtenerProvincias')
+    return [provincia.get('np') for provincia in response.json().get('consulta_provincieroResult').get('provinciero').get('prov')] if comprobar_errores(response.json()) else []
+
+def listar_municipios(provincia: str, municipio: str|None = None):
+
+    """
+    Obtiene una lista de municipios de España.
+    Args:
+        provincia (str): El nombre de la provincia. Preferentemente en mayúsculas o capitalizado.
+        municipio (str, optional): El nombre del municipio. Por defecto es None.
+    Returns:
+        List[str]: Una lista de nombres de municipios.
+    Raises:
+        Exception: Si la provincia no existe. Muestra un mensaje con las provincias disponibles.
+    """
+
+    if provincia and provincia.capitalize() not in MAPEOS_PROVINCIAS and provincia.upper() not in listar_provincias():
+            raise Exception(f'La provincia {provincia} no existe. Las provincias de España son: {listar_provincias()}')
+    
+    response = requests.get(f'{URL_BASE_CALLEJERO}/ObtenerMunicipios', 
+                                params={
+                                    'provincia' : MAPEOS_PROVINCIAS.get(provincia.capitalize()) 
+                                                    if MAPEOS_PROVINCIAS.get(provincia.capitalize(),None) != None 
+                                                    else provincia ,
+                                    'municipio': municipio
+                                })
+    if response.status_code == 200 and comprobar_errores(response.json()):
+        mun_dict_raw = json.loads(response.content)
+        return [mun.get('nm') for mun in mun_dict_raw.get('consulta_municipieroResult').get('municipiero').get('muni')]
+    else:
+         return []
+    
+
+def listar_tipos_via():
+    """
+    Retorna una lista de los tipos de vía disponibles.
+    Returns:
+        list: Una lista de los tipos de vía disponibles.
+    """
+
+    return TIPOS_VIA
+
+def listar_calles(provincia: str, municipio: str):
+    """
+    Devuelve una lista de calles para una provincia y municipio dados.
+    Args:
+        provincia (str): El nombre de la provincia.
+        municipio (str): El nombre del municipio.
+    Returns:
+        list: Una lista de calles en formato "tipo de vía nombre de vía".
+    """
+
+    provincia_final = MAPEOS_PROVINCIAS.get(provincia.capitalize()) if provincia.capitalize() in MAPEOS_PROVINCIAS.keys() else provincia
+    if provincia_final.upper() in listar_provincias() and municipio.upper() in listar_municipios(provincia=provincia_final):
+        response = requests.get(f'{URL_BASE_CALLEJERO}/ObtenerCallejero',
+                                params={
+                                    'Provincia': provincia_final,
+                                    'Municipio': municipio
+                                })
+        if response.status_code == 200 and comprobar_errores(response.json()):
+            calles_dict_raw = json.loads(response.content)
+            return [f"{calle.get('dir').get('tv')} {calle.get('dir').get('nv')}" for calle in calles_dict_raw.get('consulta_callejeroResult').get('callejero').get('calle')]
+        else:
+            return []
+    else: return []