datadis_python package

Subpackages

Module contents

Datadis Python SDK.

Un SDK modular para interactuar con la API oficial de Datadis. Soporta tanto API v1 (respuestas raw) como v2 (respuestas tipadas).

class datadis_python.DatadisClient(username, password, timeout=90, retries=5)[fuente]

Bases: object

Cliente unificado que permite acceso a ambas versiones de la API.

Parámetros:

username (str) – NIF del usuario registrado en Datadis.
password (str) – Contraseña de acceso a Datadis.
timeout (int) – Timeout para requests en segundos.
retries (int) – Número de reintentos automáticos.

__enter__()[fuente]

Context manager entry.

Devuelve:: Instancia del cliente
Tipo del valor devuelto:: DatadisClient

__exit__(exc_type, exc_val, exc_tb)[fuente]

Context manager exit.

Parámetros:

exc_type (Optional[type]) – Tipo de excepción
exc_val (Optional[BaseException]) – Valor de la excepción
exc_tb (Optional[TracebackType]) – Traceback de la excepción

__init__(username, password, timeout=90, retries=5)[fuente]

Inicializa el cliente unificado.

Parámetros:

username (str) – NIF del usuario registrado en Datadis.
password (str) – Contraseña de acceso a Datadis.
timeout (int) – Timeout para requests en segundos.
retries (int) – Número de reintentos automáticos.

close()[fuente]

Cierra ambos clientes y libera recursos.

Tipo del valor devuelto:: None

get_client_info()[fuente]

Obtiene información sobre el estado de los clientes.

Devuelve:: Diccionario con información de estado
Tipo del valor devuelto:: dict

get_consumption(cups, distributor_code, date_from, date_to, measurement_type=0, point_type=None)[fuente]

Obtiene datos de consumo (usa API v2).

Para usar v1: client.v1.get_consumption(…)

Parámetros:

cups (str) – Código CUPS del punto de suministro
distributor_code (str) – Código de la distribuidora
date_from (str) – Fecha de inicio (YYYY-MM-DD)
date_to (str) – Fecha de fin (YYYY-MM-DD)
measurement_type (int) – Tipo de medida
point_type (Optional[int]) – Tipo de punto

Devuelve:

Respuesta con datos de consumo

Tipo del valor devuelto:

ConsumptionResponse

get_contract_detail(cups, distributor_code)[fuente]

Obtiene detalle del contrato (usa API v2).

Para usar v1: client.v1.get_contract_detail(cups, distributor_code)

Parámetros:

cups (str) – Código CUPS del punto de suministro
distributor_code (str) – Código de la distribuidora

Devuelve:

Respuesta con detalle del contrato

Tipo del valor devuelto:

ContractResponse

get_cups_list()[fuente]

Obtiene solo códigos CUPS (método de conveniencia de v1).

Devuelve:: Lista de códigos CUPS
Tipo del valor devuelto:: List[str]

get_distributor_codes()[fuente]

Obtiene solo códigos de distribuidores (método de conveniencia de v1).

Devuelve:: Lista de códigos de distribuidores
Tipo del valor devuelto:: List[str]

get_distributors()[fuente]

Obtiene distribuidores (usa API v2).

Para usar v1: client.v1.get_distributors()

Devuelve:: Respuesta con distribuidores
Tipo del valor devuelto:: DistributorsResponse

get_max_power(cups, distributor_code, date_from, date_to)[fuente]

Obtiene datos de potencia máxima (usa API v2).

Para usar v1: client.v1.get_max_power(…)

Parámetros:

cups (str) – Código CUPS del punto de suministro
distributor_code (str) – Código de la distribuidora
date_from (str) – Fecha de inicio (YYYY-MM-DD)
date_to (str) – Fecha de fin (YYYY-MM-DD)

Devuelve:

Respuesta con datos de potencia máxima

Tipo del valor devuelto:

MaxPowerResponse

get_reactive_data(cups, distributor_code, date_from, date_to)[fuente]

Obtiene datos de energía reactiva (solo disponible en v2).

Parámetros:

cups (str) – Código CUPS del punto de suministro
distributor_code (str) – Código de la distribuidora
date_from (str) – Fecha de inicio (YYYY-MM-DD)
date_to (str) – Fecha de fin (YYYY-MM-DD)

Devuelve:

Lista de datos de energía reactiva

Tipo del valor devuelto:

List[ReactiveData]

get_supplies(distributor_code=None)[fuente]

Obtiene puntos de suministro (usa API v2).

Para usar v1: client.v1.get_supplies()

Parámetros:: distributor_code (Optional[str]) – Código de la distribuidora
Devuelve:: Respuesta con puntos de suministro
Tipo del valor devuelto:: SuppliesResponse

property v1: DatadisClientV1

Cliente API v1 para respuestas en formato raw.

Devuelve:: Cliente v1 inicializado
Tipo del valor devuelto:: DatadisClientV1

property v2: DatadisClientV2

Cliente API v2 para respuestas tipadas con Pydantic.

Devuelve:: Cliente v2 inicializado
Tipo del valor devuelto:: DatadisClientV2

datadis_python.DatadisClientV1: alias de SimpleDatadisClientV1

class datadis_python.DatadisClientV2(username, password, timeout=90, retries=5)[fuente]

Bases: BaseDatadisClient

Cliente para API v2 de Datadis.

Características: - Devuelve datos raw exactamente como los proporciona la API - Endpoints v2 con estructura de respuesta actualizada - Validación de parámetros de entrada - Manejo de errores de distribuidor en formato v2

Parámetros:

username (str) – NIF del usuario registrado en Datadis.
password (str) – Contraseña de acceso a Datadis.
timeout (int) – Timeout para requests en segundos.
retries (int) – Número de reintentos automáticos.

get_consumption(cups, distributor_code, date_from, date_to, measurement_type=0, point_type=None, authorized_nif=None)[fuente]

Buscar los datos de consumo.

Parámetros:

cups (str) – Los CUPS de los que querremos saber los datos de consumo.
distributor_code (str) – Código del distribuidor, que se obtiene con la solicitud de obtención de suministros.
date_from (str) – Fecha de inicio entre los datos de búsqueda. Formato: AAAA/MM. Ejemplo = 2020/02.
date_to (str) – Fecha de finalización entre los datos de búsqueda. Formato: AAAA/MM. Ejemplo = 2020/02.
measurement_type (int) – Establézcalo en 0 (Cero) si desea obtener el consumo por hora y en 1 (Uno) si desea obtener el consumo por cuarto de hora. La consulta cuarta horaria solo está disponible para los PointType 1 y 2, y en el caso de la distribuidora E-distribución adicionalmente el PointType 3.
point_type (Optional[int]) – Código de tipo de punto, que se obtiene con la solicitud de obtención de suministros.
authorized_nif (Optional[str]) – Solo en caso que se quiera obtener los datos de consumo de un NIF autorizado.

Devuelve:

Respuesta con datos de consumo validados y errores de distribuidora en formato v2.

Tipo del valor devuelto:

ConsumptionResponse

get_contract_detail(cups, distributor_code, authorized_nif=None)[fuente]

Buscar el detalle del contrato.

Parámetros:

cups (str) – Los CUPS de los que querremos saber los detalles del contrato. Solo puede buscar un CUPS por pedido.
distributor_code (str) – Código del distribuidor, que se obtiene con la solicitud de obtención de suministros.
authorized_nif (Optional[str]) – Solo en el caso de que quieras obtener el detalle del contrato del NIF autorizado.

Devuelve:

Respuesta con datos de contrato validados y errores de distribuidora en formato v2.

Tipo del valor devuelto:

ContractResponse

get_distributors(authorized_nif=None)[fuente]

Obtiene una lista de códigos de distribuidores en los que el usuario tiene suministros.

Parámetros:: authorized_nif (Optional[str]) – Únicamente en caso de querer obtener el listado de códigos de distribuidoras que disponen de suministros del NIF autorizado.
Devuelve:: Respuesta con códigos de distribuidores validados y errores en formato v2.
Tipo del valor devuelto:: DistributorsResponse
Note:: Códigos de distribuidora: (1: Viesgo, 2: E-distribución, 3: E-redes, 4: ASEME, 5: UFD, 6: EOSA, 7:CIDE, 8: IDE)

get_max_power(cups, distributor_code, date_from, date_to, authorized_nif=None)[fuente]

Busca la potencia máxima y te aparecerá el resultado en kW.

Parámetros:

cups (str) – Las CUPS de las que querremos conocer los detalles del contrato.
distributor_code (str) – Código del distribuidor, que se obtiene con la solicitud de obtención de suministros.
date_from (str) – Fecha de inicio entre los datos de búsqueda. Formato: AAAA/MM. Ejemplo = 2020/02.
date_to (str) – Fecha de finalización entre los datos de búsqueda. Formato: AAAA/MM. Ejemplo = 2020/02.
authorized_nif (Optional[str]) – Solo en el caso de que quieras obtener el detalle del contrato del NIF autorizado.

Devuelve:

Respuesta con datos de potencia máxima validados y errores de distribuidora en formato v2.

Tipo del valor devuelto:

MaxPowerResponse

get_reactive_data(cups, distributor_code, date_from, date_to, authorized_nif=None)[fuente]

Buscar datos de energía reactiva (solo disponible en v2).

Parámetros:

cups (str) – Los CUPS de los que querremos saber los datos de consumo.
distributor_code (str) – Código del distribuidor, que se obtiene con la solicitud de obtención de suministros.
date_from (str) – Fecha de inicio entre los datos de búsqueda. Formato: AAAA/MM. Ejemplo = 2020/02.
date_to (str) – Fecha de finalización entre los datos de búsqueda. Formato: AAAA/MM. Ejemplo = 2020/02.
authorized_nif (Optional[str]) – Solo en caso que se quiera obtener los datos de consumo de un NIF autorizado.

Devuelve:

Lista de objetos ReactiveData validados.

Tipo del valor devuelto:

List[ReactiveData]

get_supplies(authorized_nif=None, distributor_code=None)[fuente]

Buscar todos los suministros.

Parámetros:

authorized_nif (Optional[str]) – Si queremos buscar suministros de personas que hemos autorizado, podemos buscarlo con el NIF de las personas autorizadas.
distributor_code (Optional[str]) – Código del distribuidor, que se obtiene con la solicitud de distribuidoras con suministros: /get-distributors-with-supplies. Para consultar los suministros de una sola distribuidora.

Devuelve:

Respuesta con suministros validados y errores de distribuidora en formato v2.

Tipo del valor devuelto:

SuppliesResponse

datadis_python.DatadisClientLegacy: alias de DatadisClient

exception datadis_python.DatadisError[fuente]

Bases: Exception

Base exception for Datadis SDK.

Esta es la excepción base de la cual heredan todas las demás excepciones del SDK.

exception datadis_python.AuthenticationError[fuente]

Bases: DatadisError

Authentication related errors.

Se lanza cuando hay problemas con la autenticación del usuario.

exception datadis_python.APIError(message, status_code=None)[fuente]

Bases: DatadisError

API response errors.

Se lanza cuando la API de Datadis devuelve errores HTTP.

Parámetros:

message (str) – Mensaje de error
status_code (int) – Código de estado HTTP (opcional)

__init__(message, status_code=None)[fuente]

Inicializa una excepción de error de API.

Parámetros:

message (str) – Mensaje de error
status_code (int) – Código de estado HTTP (opcional)

class datadis_python.SupplyData(*, address, cups, postalCode, province, municipality, distributor, validDateFrom, validDateTo=None, pointType, distributorCode)[fuente]

Bases: BaseModel

Modelo Pydantic para datos de puntos de suministro eléctrico españoles.

Representa la información completa de un punto de suministro (CUPS) registrado en el sistema eléctrico español. Cada objeto contiene todos los datos técnicos, geográficos y contractuales necesarios para identificar y trabajar con un punto de conexión específico a la red eléctrica nacional.

Información del punto de suministro:

Identificación única: Código CUPS de 20-22 caracteres
Ubicación física: Dirección completa, código postal, provincia y municipio
Información técnica: Tipo de punto de medida y clasificación
Datos del distribuidor: Empresa responsable de la red en la zona
Período contractual: Fechas de validez del contrato actual

Tipos de punto de medida (point_type):

Tipo 1: Potencia contratada > 450 kW (grandes industrias)
Tipo 2: 50 kW < Potencia ≤ 450 kW (medianas industrias)
Tipo 3: 15 kW < Potencia ≤ 50 kW (pequeñas industrias, grandes comercios)
Tipo 4: 10 kW < Potencia ≤ 15 kW (pequeños comercios, grandes viviendas)
Tipo 5: Potencia ≤ 10 kW (viviendas domésticas típicas)

Estructura del código CUPS:

Formato: ESXXXXXXXXXXXXXXXXXXX
Longitud: 20-22 caracteres alfanuméricos
Prefijo: Siempre «ES» para España
Identificador: Único a nivel nacional
Verificación: Dígitos de control incluidos

Distribuidores por zona geográfica:

Viesgo (1): Cantabria, Asturias
E-distribución (2): Cobertura nacional, mayor distribuidor
E-redes (3): Galicia
ASEME (4): Melilla (ciudad autónoma)
UFD (5): Nacional, especialmente Cataluña y Madrid
EOSA (6): Aragón
CIDE (7): Ceuta (ciudad autónoma)
IDE (8): Islas Baleares

Ejemplo

Análisis básico de un punto de suministro:

from datadis_python.models.supply import SupplyData

# Punto de suministro doméstico típico
supply_home = SupplyData(
    address="Calle Mayor 123, 1º A",
    cups="ES001234567890123456AB",
    postalCode="28001",
    province="Madrid",
    municipality="Madrid",
    distributor="E-distribución",
    validDateFrom="2023/01/15",
    validDateTo=None,  # Contrato activo
    pointType=5,  # Doméstico
    distributorCode="2"  # E-distribución
)

print(f"CUPS: {supply_home.cups}")
print(f"Ubicación: {supply_home.address}")
print(f"Zona: {supply_home.municipality}, {supply_home.province}")
print(f"Distribuidor: {supply_home.distributor}")

# Determinar tipo de instalación
point_types = {
    1: "Gran industria (>450 kW)",
    2: "Mediana industria (50-450 kW)",
    3: "Pequeña industria (15-50 kW)",
    4: "Comercio/gran vivienda (10-15 kW)",
    5: "Vivienda doméstica (≤10 kW)"
}

print(f"Tipo: {point_types.get(supply_home.point_type, 'Desconocido')}")

Análisis de vigencia contractual:

from datetime import datetime

def analyze_contract_validity(supply: SupplyData) -> str:
    \"\"\"Analiza el estado del contrato del suministro.\"\"\"

    if supply.valid_date_to is None:
        return "✅ Contrato activo (sin fecha de fin)"

    # Parsear fecha de fin (formato YYYY/MM/DD)
    try:
        end_date = datetime.strptime(supply.valid_date_to, "%Y/%m/%d")
        current_date = datetime.now()

        if end_date > current_date:
            days_remaining = (end_date - current_date).days
            return f"✅ Contrato activo ({days_remaining} días restantes)"
        else:
            return "❌ Contrato expirado"
    except ValueError:
        return "⚠️ Fecha de fin inválida"

# Usar la función
status = analyze_contract_validity(supply_home)
print(f"Estado contractual: {status}")

Agrupación por distribuidor:

# Lista de suministros de un usuario
supplies = [
    SupplyData(
        address="Calle A", cups="ES0012...", postalCode="28001",
        province="Madrid", municipality="Madrid", distributor="E-distribución",
        validDateFrom="2023/01/01", pointType=5, distributorCode="2"
    ),
    SupplyData(
        address="Calle B", cups="ES0034...", postalCode="08001",
        province="Barcelona", municipality="Barcelona", distributor="UFD",
        validDateFrom="2022/06/15", pointType=4, distributorCode="5"
    )
]

# Agrupar por distribuidor
by_distributor = {}
for supply in supplies:
    dist_name = supply.distributor
    if dist_name not in by_distributor:
        by_distributor[dist_name] = []
    by_distributor[dist_name].append(supply)

print("Suministros por distribuidor:")
for distributor, supply_list in by_distributor.items():
    print(f"- {distributor}: {len(supply_list)} suministros")
    for supply in supply_list:
        print(f"  * {supply.municipality} ({supply.cups[:8]}...)")

Validación de código CUPS:

def validate_cups_format(cups: str) -> bool:
    \"\"\"Valida formato básico del código CUPS español.\"\"\"

    # Verificaciones básicas
    if not cups.startswith("ES"):
        return False
    if len(cups) < 20 or len(cups) > 22:
        return False
    if not cups[2:].isalnum():
        return False

    return True

# Validar CUPS
if validate_cups_format(supply_home.cups):
    print("✅ Formato CUPS válido")
else:
    print("❌ Formato CUPS inválido")

Análisis geográfico:

# Identificar región por distribuidor
regions = {
    "1": "Norte (Cantabria/Asturias)",
    "2": "Nacional (E-distribución)",
    "3": "Galicia",
    "4": "Melilla",
    "5": "Nacional (UFD)",
    "6": "Aragón",
    "7": "Ceuta",
    "8": "Baleares"
}

region = regions.get(supply_home.distributor_code, "Región desconocida")
print(f"Región de distribución: {region}")

Parámetros:

address (str) – Dirección física completa del punto de suministro. Incluye calle, número, piso/puerta si aplica. Corresponde a la ubicación real donde se encuentra la instalación eléctrica
cups (str) – Código CUPS (Código Único del Punto de Suministro). Identificador alfanumérico único de 20-22 caracteres que identifica inequívocamente el punto de conexión a la red eléctrica española
postal_code (str) – Código postal de la dirección del suministro. Código numérico de 5 dígitos que identifica la zona postal española
province (str) – Provincia española donde se ubica el punto de suministro. Corresponde a la división administrativa de primer nivel
municipality (str) – Municipio donde se encuentra el suministro eléctrico. División administrativa local dentro de la provincia
distributor (str) – Nombre comercial de la empresa distribuidora responsable de la red eléctrica en la zona geográfica del suministro
valid_date_from (str) – Fecha de inicio de validez del contrato actual en formato YYYY/MM/DD. Marca el comienzo del período contractual vigente
valid_date_to (Optional[str]) – Fecha de finalización del contrato en formato YYYY/MM/DD. None para contratos sin fecha de fin definida (más común)
point_type (int) – Tipo de punto de medida según clasificación técnica española. Entero del 1 al 5 que determina el tipo de instalación y medición
distributor_code (str) – Código numérico del distribuidor (1-8). Identificador único usado en las consultas API para el distribuidor específico
postalCode (str)
validDateFrom (str)
validDateTo (str | None)
pointType (int)
distributorCode (str)

Muestra:

ValidationError – Si algún campo obligatorio falta o tiene formato incorrecto

Nota

El point_type determina el tipo de contador y sistema de medición. Los tipos 1-3 suelen tener medición cuarto-horaria, los tipos 4-5 horaria.

Truco

Use el distributor_code para consultas posteriores de consumo, contratos y otros datos específicos del punto de suministro.

Ver también

SuppliesResponse - Respuesta estructurada de la API V2 que contiene estos datos
SimpleDatadisClientV1.get_supplies() - Obtener puntos de suministro V1
SimpleDatadisClientV2.get_supplies() - Obtener puntos de suministro V2
Códigos CUPS oficiales en la documentación del sistema eléctrico español

Added in version 1.0: Modelo base para puntos de suministro del sistema eléctrico español

model_config: ClassVar[ConfigDict] = {'populate_by_name': True, 'validate_by_alias': True, 'validate_by_name': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

address: str

cups: str

postal_code: str

province: str

municipality: str

distributor: str

valid_date_from: str

valid_date_to: str | None

point_type: int

distributor_code: str

class datadis_python.ContractData(*, cups, distributor, marketer=None, tension, accessFare, province, municipality, postalCode, contractedPowerkW, timeDiscrimination=None, modePowerControl, startDate, endDate=None, codeFare, selfConsumptionTypeCode=None, selfConsumptionTypeDesc=None, section=None, subsection=None, partitionCoefficient=None, cau=None, installedCapacityKW=None, dateOwner=None, lastMarketerDate=None, maxPowerInstall=None)[fuente]

Bases: BaseModel

Modelo Pydantic completo para datos contractuales de suministros eléctricos.

Representa la información contractual completa de un punto de suministro (CUPS), incluyendo datos técnicos, comerciales, tarifarios y de autoconsumo. Este modelo contiene toda la información relevante sobre el contrato eléctrico asociado a una instalación, desde datos básicos hasta configuraciones avanzadas de autoconsumo.

Información contractual incluida:

Datos básicos: CUPS, distribuidor, comercializadora, ubicación
Información técnica: Tensión, potencias contratadas, control de potencia
Datos tarifarios: Tarifa de acceso, discriminación horaria, códigos CNMC
Autoconsumo: Tipo, configuración, coeficientes, CAU
Histórico: Períodos de propiedad, cambios de comercializadora

Tipos de instalaciones soportadas:

Consumo tradicional: Sin generación propia
Autoconsumo individual: Instalación fotovoltaica privada
Autoconsumo colectivo: Instalaciones compartidas entre varios usuarios
Autoconsumo con excedentes: Venta de energía sobrante a la red
Autoconsumo sin excedentes: Generación solo para consumo propio

Códigos de tarifa de acceso (CNMC):

2.0TD: Baja tensión ≤ 15 kW (doméstico típico)
3.0TD: Baja tensión > 15 kW ≤ 100 kW (comercios, pequeña industria)
6.1TD: Alta tensión 1-36 kV (gran industria)
6.2TD: Alta tensión 36-72.5 kV
6.3TD: Alta tensión 72.5-145 kV
6.4TD: Alta tensión ≥ 145 kV

Ejemplo

Contrato doméstico básico sin autoconsumo:

from datadis_python.models.contract import ContractData

# Vivienda típica con tarifa 2.0TD
contract_home = ContractData(
    cups="ES001234567890123456AB",
    distributor="E-distribución",
    marketer="Iberdrola",
    tension="BT",
    accessFare="2.0TD (Peaje de acceso 2.0TD)",
    province="Madrid",
    municipality="Madrid",
    postalCode="28001",
    contractedPowerkW=[5.75],  # 5.75 kW contratados
    timeDiscrimination="DHA",   # Discriminación horaria
    modePowerControl="ICP",     # Interruptor Control Potencia
    startDate="2023/01/15",
    codeFare="2.0TD"
)

print(f"Potencia contratada: {contract_home.contracted_power_kw[0]} kW")
print(f"Tarifa: {contract_home.code_fare}")

Instalación con autoconsumo fotovoltaico:

from datadis_python.models.contract import ContractData, DateOwner

# Casa con paneles solares y autoconsumo
contract_solar = ContractData(
    cups="ES001234567890123456AB",
    distributor="UFD",
    marketer="Naturgy",
    tension="BT",
    accessFare="2.0TD con autoconsumo",
    province="Valencia",
    municipality="Valencia",
    postalCode="46001",
    contractedPowerkW=[4.60],
    modePowerControl="ICP",
    startDate="2022/03/01",
    codeFare="2.0TD",
    # Configuración de autoconsumo
    selfConsumptionTypeCode="41",
    selfConsumptionTypeDesc="Autoconsumo con excedentes acogido a compensación",
    installedCapacityKW=5.0,  # 5 kW de paneles solares
    cau="ES00123456789",      # Código de Autoconsumo Único
    dateOwner=[
        DateOwner(startDate="2022/03/01", endDate="2024/12/31")
    ]
)

print(f"Tipo autoconsumo: {contract_solar.self_consumption_type_desc}")
print(f"Potencia instalada: {contract_solar.installed_capacity_kw} kW")

Autoconsumo colectivo con coeficiente de reparto:

# Instalación compartida en comunidad de vecinos
contract_collective = ContractData(
    cups="ES001234567890123456AB",
    distributor="E-distribución",
    tension="BT",
    accessFare="2.0TD autoconsumo colectivo",
    province="Barcelona",
    municipality="Barcelona",
    postalCode="08001",
    contractedPowerkW=[3.45],
    codeFare="2.0TD",
    selfConsumptionTypeCode="43",
    selfConsumptionTypeDesc="Autoconsumo colectivo con excedentes",
    partitionCoefficient=0.15,  # 15% del total generado
    cau="ES00987654321",
    installedCapacityKW=20.0,    # Instalación total compartida
    startDate="2023/06/01"
)

print(f"Coeficiente de reparto: {contract_collective.partition_coefficient}")

Parámetros:

cups (str) – Código CUPS del punto de suministro. Identificador único nacional de 20-22 caracteres que identifica inequívocamente el punto de conexión
distributor (str) – Nombre de la empresa distribuidora responsable de la red en la zona geográfica del suministro
marketer (Optional[str]) – Empresa comercializadora que factura la energía. Solo visible si el usuario autenticado es propietario del CUPS
tension (str) – Nivel de tensión del suministro. Valores típicos: «BT» (Baja Tensión), «AT» (Alta Tensión), «MT» (Media Tensión)
access_fare (str) – Descripción completa de la tarifa de acceso aplicable. Incluye el código y descripción extendida
province (str) – Provincia donde se ubica físicamente el punto de suministro
municipality (str) – Municipio de ubicación del suministro eléctrico
postal_code (str) – Código postal de la dirección del punto de suministro
contracted_power_kw (List[float]) – Lista de potencias contratadas en kW por período tarifario. Para tarifas simples: un valor. Para discriminación horaria: múltiples valores
time_discrimination (Optional[str]) – Tipo de discriminación horaria aplicada. Valores típicos: «DHA» (Discriminación Horaria), «DHS» (Supervalle), None (tarifa simple)
mode_power_control (str) – Sistema de control de la potencia contratada. «ICP» (Interruptor Control Potencia) o «Maxímetro»
start_date (str) – Fecha de inicio de vigencia del contrato en formato YYYY/MM/DD
end_date (Optional[str]) – Fecha de finalización del contrato. None para contratos activos
code_fare (str) – Código oficial de la tarifa de acceso según clasificación CNMC. Define la estructura tarifaria aplicable
self_consumption_type_code (Optional[str]) – Código numérico del tipo de autoconsumo según RD 244/2019. Códigos 4X para diferentes modalidades de autoconsumo
self_consumption_type_desc (Optional[str]) – Descripción detallada del tipo de autoconsumo configurado. Especifica modalidad, excedentes y acogimiento a compensación
section (Optional[str]) – Clasificación de sección para autoconsumo según normativa vigente
subsection (Optional[str]) – Subclasificación específica dentro de la sección de autoconsumo
partition_coefficient (Optional[float]) – Coeficiente de reparto para autoconsumo colectivo. Porcentaje de la energía generada asignado a este CUPS (0.0-1.0)
cau (Optional[str]) – Código de Autoconsumo Único. Identificador oficial de la instalación de autoconsumo asignado por la administración competente
installed_capacity_kw (Optional[float]) – Potencia pico instalada de generación renovable en kW. Suma de toda la capacidad de generación asociada al autoconsumo
date_owner (Optional[List[DateOwner]]) – Lista de períodos durante los cuales el usuario autenticado ha sido propietario del punto de suministro
last_marketer_date (Optional[str]) – Fecha del último cambio de empresa comercializadora en formato YYYY/MM/DD
max_power_install (Optional[str]) – Potencia máxima de la instalación eléctrica en formato texto. Puede incluir información adicional sobre limitaciones técnicas
accessFare (str)
postalCode (str)
contractedPowerkW (List[float])
timeDiscrimination (str | None)
modePowerControl (str)
startDate (str)
endDate (str | None)
codeFare (str)
selfConsumptionTypeCode (str | None)
selfConsumptionTypeDesc (str | None)
partitionCoefficient (float | None)
installedCapacityKW (float | None)
dateOwner (List[DateOwner] | None)
lastMarketerDate (str | None)
maxPowerInstall (str | None)

Muestra:

ValidationError – Si algún campo obligatorio está ausente o tiene formato incorrecto

Nota

Para autoconsumo colectivo, el partition_coefficient debe sumar 1.0 entre todos los participantes de la instalación compartida.

Ver también

DateOwner - Modelo para períodos de propiedad
ContractResponse - Respuesta estructurada de la API V2
SimpleDatadisClientV2.get_contract_detail() - Obtener datos contractuales
RD 244/2019 para códigos de autoconsumo oficiales

Added in version 2.0: Soporte completo para autoconsumo y datos contractuales extendidos

model_config: ClassVar[ConfigDict] = {'populate_by_name': True, 'validate_by_alias': True, 'validate_by_name': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

cups: str

distributor: str

marketer: str | None

tension: str

access_fare: str

province: str

municipality: str

postal_code: str

contracted_power_kw: List[float]

time_discrimination: str | None

mode_power_control: str

start_date: str

end_date: str | None

code_fare: str

self_consumption_type_code: str | None

self_consumption_type_desc: str | None

section: str | None

subsection: str | None

partition_coefficient: float | None

cau: str | None

installed_capacity_kw: float | None

date_owner: List[DateOwner] | None

last_marketer_date: str | None

max_power_install: str | None

class datadis_python.ConsumptionData(*, cups, date, time, consumptionKWh, obtainMethod, surplusEnergyKWh=None, generationEnergyKWh=None, selfConsumptionEnergyKWh=None)[fuente]

Bases: BaseModel

Modelo Pydantic para datos de consumo energético de Datadis.

Representa una medición de consumo eléctrico proveniente de los contadores inteligentes de las distribuidoras eléctricas españolas. Los datos incluyen tanto consumo tradicional como información de autoconsumo y generación para instalaciones con paneles solares u otras fuentes de energía renovable.

Características principales:

Validación automática: Todos los campos se validan con Pydantic
Compatibilidad de alias: Soporta tanto nombres Python como nombres API
Datos de autoconsumo: Información completa para instalaciones fotovoltaicas
Granularidad temporal: Mediciones horarias o cuarto-horarias según disponibilidad
Métodos de obtención: Distingue entre mediciones reales y estimadas

Tipos de mediciones soportadas:

Consumo tradicional: Energía consumida de la red eléctrica
Autoconsumo: Energía generada y consumida localmente (sin pasar por la red)
Excedentes/Vertidos: Energía generada y vendida a la red eléctrica
Generación total: Energía total producida por la instalación renovable

Métodos de obtención de datos:

«Real»: Medición directa del contador inteligente
«Estimada»: Estimación basada en patrones históricos o interpolación
«Provisional»: Datos preliminares pendientes de validación final

Ejemplo

Uso básico del modelo:

from datadis_python.models.consumption import ConsumptionData

# Datos típicos de consumo sin autoconsumo
consumption_basic = ConsumptionData(
    cups="ES001234567890123456AB",
    date="2024/12/15",
    time="14:00",
    consumptionKWh=2.45,
    obtainMethod="Real"
)

print(f"Consumo: {consumption_basic.consumption_kwh} kWh")
print(f"Método: {consumption_basic.obtain_method}")

Datos de instalación con autoconsumo fotovoltaico:

# Instalación con paneles solares
consumption_solar = ConsumptionData(
    cups="ES001234567890123456AB",
    date="2024/07/20",
    time="13:00",  # Hora de máxima producción solar
    consumptionKWh=0.25,      # Poca energía de la red
    obtainMethod="Real",
    surplusEnergyKWh=3.20,    # Excedente vendido a la red
    generationEnergyKWh=5.80, # Generación total de paneles
    selfConsumptionEnergyKWh=2.60  # Autoconsumo directo
)

# Verificar balance energético
total_consumption = (consumption_solar.consumption_kwh +
                   consumption_solar.self_consumption_energy_kwh)
print(f"Consumo total real: {total_consumption} kWh")
print(f"Excedente vendido: {consumption_solar.surplus_energy_kwh} kWh")

Validación automática con alias:

# Usando nombres de la API (camelCase)
data_api = {
    "cups": "ES001234567890123456AB",
    "date": "2024/12/15",
    "time": "10:30",
    "consumptionKWh": 1.85,  # Nombre API
    "obtainMethod": "Estimada"
}

consumption = ConsumptionData(**data_api)
print(f"Consumo: {consumption.consumption_kwh}")  # Acceso Python

Parámetros:

cups (str) – Código CUPS del punto de suministro. Identificador único de 22 caracteres que identifica de forma inequívoca el punto de conexión a la red eléctrica
date (str) – Fecha de la medición en formato YYYY/MM/DD. Corresponde al día de la lectura del contador, en zona horaria española (CET/CEST)
time (str) – Hora de la medición en formato HH:MM (24h). Para mediciones horarias normalmente :00, para cuarto-horarias :00, :15, :30, :45
consumption_kwh (float) – Energía activa consumida desde la red eléctrica en kWh. Representa la energía que el usuario ha tomado de la red durante el período de medición
obtain_method (str) – Método de obtención de los datos. Valores posibles: «Real» (medición directa), «Estimada» (cálculo), «Provisional»
surplus_energy_kwh (Optional[float]) – Energía excedentaria vertida a la red en kWh. Solo aplica para instalaciones de autoconsumo con excedentes. Representa la energía generada localmente y vendida/cedida a la red
generation_energy_kwh (Optional[float]) – Energía total generada por la instalación renovable en kWh. Suma del autoconsumo directo más los excedentes vertidos. Solo aplica para instalaciones con generación propia
self_consumption_energy_kwh (Optional[float]) – Energía autoconsumida directamente en kWh. Energía generada localmente y consumida sin pasar por la red. Solo aplica para instalaciones de autoconsumo
consumptionKWh (float)
obtainMethod (str)
surplusEnergyKWh (float | None)
generationEnergyKWh (float | None)
selfConsumptionEnergyKWh (float | None)

Muestra:

ValidationError – Si algún campo no cumple las validaciones de Pydantic (tipos incorrectos, valores nulos en campos obligatorios, etc.)

Nota

Para instalaciones con autoconsumo, se cumple la ecuación: generation_energy_kwh = self_consumption_energy_kwh + surplus_energy_kwh

Ver también

ConsumptionResponse - Respuesta estructurada de la API V2
SimpleDatadisClientV1.get_consumption() - Obtener datos V1
SimpleDatadisClientV2.get_consumption() - Obtener datos V2

model_config: ClassVar[ConfigDict] = {'populate_by_name': True, 'validate_by_alias': True, 'validate_by_name': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

cups: str

date: str

time: str

consumption_kwh: float

obtain_method: str

surplus_energy_kwh: float | None

generation_energy_kwh: float | None

self_consumption_energy_kwh: float | None

class datadis_python.MaxPowerData(*, cups, date, time, maxPower, period)[fuente]

Bases: BaseModel

Modelo Pydantic para datos de potencia máxima demandada en suministros eléctricos.

Representa el registro de potencia eléctrica máxima demandada en un punto de suministro durante un período determinado. Esta información es crucial para la facturación eléctrica, optimización de contratos y análisis de consumo, especialmente en instalaciones comerciales e industriales con control por maxímetro.

Conceptos fundamentales:

Potencia máxima: Pico de demanda eléctrica registrado en un período
Control por maxímetro: Sistema que registra automáticamente los picos de potencia
Períodos tarifarios: Franjas horarias con diferentes precios de energía
Penalizaciones: Excesos sobre la potencia contratada pueden generar recargos

Sistemas de control de potencia en España:

ICP (Interruptor Control Potencia): Corta el suministro si se excede la potencia
Maxímetro: Registra los picos pero permite el consumo (con posible recargo)

Períodos tarifarios comunes:

PUNTA: Horas de mayor demanda nacional (18:00-22:00 invierno)
LLANO: Horas intermedias de demanda
VALLE: Horas de menor demanda (01:00-08:00)
P1-P6: Períodos numerados según discriminación horaria específica

Ejemplo

Análisis de potencia máxima doméstica:

from datadis_python.models.max_power import MaxPowerData

# Pico de potencia en hora punta
max_power_home = MaxPowerData(
    cups="ES001234567890123456AB",
    date="2024/12/15",
    time="19:30",  # Hora punta de invierno
    maxPower=4250.0,  # 4.25 kW
    period="PUNTA"
)

print(f"Potencia máxima: {max_power_home.max_power / 1000:.2f} kW")
print(f"Momento pico: {max_power_home.date} a las {max_power_home.time}")
print(f"Período tarifario: {max_power_home.period}")

# Verificar si excede potencia contratada
potencia_contratada = 5750  # 5.75 kW en W
if max_power_home.max_power > potencia_contratada:
    exceso = max_power_home.max_power - potencia_contratada
    print(f"⚠️ Exceso: {exceso:.0f} W sobre lo contratado")
else:
    print("✅ Dentro de la potencia contratada")

Instalación comercial con múltiples períodos:

# Ejemplo de pequeño comercio
power_records = [
    MaxPowerData(
        cups="ES009876543210987654AB",
        date="2024/11/20",
        time="09:15",
        maxPower=12500.0,  # 12.5 kW
        period="LLANO"
    ),
    MaxPowerData(
        cups="ES009876543210987654AB",
        date="2024/11/20",
        time="20:45",
        maxPower=15200.0,  # 15.2 kW
        period="PUNTA"
    )
]

# Analizar picos por período
for record in power_records:
    kw_power = record.max_power / 1000
    print(f"Período {record.period}: {kw_power:.1f} kW a las {record.time}")

Optimización de contrato basada en datos históricos:

from datadis_python.client.v2 import SimpleDatadisClientV2

with SimpleDatadisClientV2("12345678A", "password") as client:
    # Obtener datos de potencia máxima del último año
    max_power_response = client.get_max_power(
        cups="ES001234567890123456AB",
        distributor_code="2",
        date_from="2024/01",
        date_to="2024/12"
    )

    # Analizar patrones para optimizar contrato
    monthly_peaks = {}
    for power_data in max_power_response.max_power_data:
        month = power_data.date[:7]  # YYYY/MM
        current_peak = monthly_peaks.get(month, 0)
        monthly_peaks[month] = max(current_peak, power_data.max_power)

    avg_peak = sum(monthly_peaks.values()) / len(monthly_peaks)
    print(f"Potencia promedio máxima: {avg_peak/1000:.2f} kW")

Parámetros:

cups (str) – Código CUPS del punto de suministro. Identificador único del punto de conexión donde se registró la potencia máxima
date (str) – Fecha en que se registró la potencia máxima en formato YYYY/MM/DD. Corresponde al día específico en que ocurrió el pico de demanda
time (str) – Hora exacta del pico de potencia en formato HH:MM (24h). Momento preciso en que se registró la demanda máxima del período
max_power (float) – Potencia máxima demandada expresada en vatios (W). Representa el pico de consumo eléctrico registrado en el momento especificado
period (str) – Período tarifario en el que ocurrió el pico. Valores típicos: «PUNTA», «LLANO», «VALLE» o códigos numéricos «P1»-«P6» según discriminación horaria
maxPower (float)

Muestra:

ValidationError – Si algún campo obligatorio falta o tiene formato incorrecto

Nota

La potencia se expresa en vatios (W). Para convertir a kilovatios: max_power / 1000

Truco

Para instalaciones con ICP, los picos registrados normalmente no excederán la potencia contratada ya que el interruptor cortaría el suministro.

Ver también

MaxPowerResponse - Respuesta estructurada de la API V2
SimpleDatadisClientV1.get_max_power() - Obtener datos V1
SimpleDatadisClientV2.get_max_power() - Obtener datos V2
ContractData - Información sobre potencias contratadas

Added in version 1.0: Soporte para datos de potencia máxima de contadores inteligentes

model_config: ClassVar[ConfigDict] = {'populate_by_name': True, 'validate_by_alias': True, 'validate_by_name': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

cups: str

date: str

time: str

max_power: float

period: str

class datadis_python.SuppliesResponse(**data)[fuente]

Bases: BaseModel

Modelo Pydantic para respuesta estructurada del endpoint get-supplies V2.

Respuesta completa y robusta del endpoint get_supplies de la API V2 que incluye tanto los datos de puntos de suministro como información detallada sobre errores específicos por distribuidor. Esta estructura permite obtener datos parciales incluso cuando algunos distribuidores experimentan problemas.

Ventajas de la estructura V2:

Datos resilientes: Obtención de suministros incluso con errores parciales
Diagnóstico detallado: Información específica sobre problemas por distribuidor
Transparencia total: Visibilidad completa del estado de cada consulta
Manejo granular: Procesamiento inteligente de respuestas mixtas

Escenarios de respuesta típicos:

Éxito completo: Todos los suministros obtenidos, sin errores
Éxito parcial: Algunos suministros obtenidos, errores en distribuidores específicos
Fallo parcial: Datos limitados debido a múltiples errores de distribuidor
Fallo total: Sin datos, errores en todos los distribuidores consultados

Ejemplo

Respuesta exitosa completa:

from datadis_python.client.v2 import SimpleDatadisClientV2

with SimpleDatadisClientV2("12345678A", "password") as client:
    response = client.get_supplies()

print(f"Suministros encontrados: {len(response.supplies)}")
print(f"Errores por distribuidor: {len(response.distributor_error)}")

if not response.distributor_error:
    print("✅ Respuesta completa sin errores")

    # Procesar todos los suministros
    for supply in response.supplies:
        print(f"CUPS: {supply.cups}")
        print(f"Dirección: {supply.address}")
        print(f"Distribuidor: {supply.distributor} (código: {supply.distributor_code})")
        print("---")
else:
    print("⚠️ Respuesta con errores parciales")

Manejo de respuesta con errores:

# Analizar errores específicos por distribuidor
if response.distributor_error:
    print("Problemas detectados:")
    for error in response.distributor_error:
        print(f"- {error.distributor_name}: {error.error_description}")

    # Determinar si los datos disponibles son útiles
    error_distributors = {error.distributor_code for error in response.distributor_error}
    available_supplies = [s for s in response.supplies
                        if s.distributor_code not in error_distributors]

    print(f"Suministros utilizables: {len(available_supplies)}")

    if available_supplies:
        print("Datos parciales disponibles para procesamiento")
    else:
        print("Sin datos utilizables - todos los distribuidores con errores")

Análisis por distribuidor:

# Agrupar suministros por distribuidor
supplies_by_distributor = {}
for supply in response.supplies:
    dist_code = supply.distributor_code
    if dist_code not in supplies_by_distributor:
        supplies_by_distributor[dist_code] = []
    supplies_by_distributor[dist_code].append(supply)

# Mostrar estadísticas
print("Distribución de suministros:")
distributor_names = {
    "1": "Viesgo", "2": "E-distribución", "3": "E-redes",
    "4": "ASEME", "5": "UFD", "6": "EOSA", "7": "CIDE", "8": "IDE"
}

for dist_code, supplies_list in supplies_by_distributor.items():
    dist_name = distributor_names.get(dist_code, f"Distribuidor {dist_code}")
    print(f"- {dist_name}: {len(supplies_list)} suministros")

# Verificar errores por distribuidor
error_codes = {error.distributor_code for error in response.distributor_error}
for dist_code in supplies_by_distributor.keys():
    if dist_code in error_codes:
        print(f"  ⚠️ {distributor_names.get(dist_code)}: Datos incompletos")

Filtrado inteligente para uso posterior:

def get_reliable_supplies(response: SuppliesResponse):
    \"\"\"Obtiene solo suministros de distribuidores sin errores.\"\"\"

    # Identificar distribuidores problemáticos
    problem_distributors = {error.distributor_code
                          for error in response.distributor_error}

    # Filtrar suministros confiables
    reliable_supplies = [
        supply for supply in response.supplies
        if supply.distributor_code not in problem_distributors
    ]

    print(f"Suministros confiables: {len(reliable_supplies)}/{len(response.supplies)}")
    return reliable_supplies

# Usar solo datos confiables para consultas posteriores
reliable_supplies = get_reliable_supplies(response)

if reliable_supplies:
    # Continuar con análisis de consumo solo para suministros confiables
    first_supply = reliable_supplies[0]
    consumption_response = client.get_consumption(
        cups=first_supply.cups,
        distributor_code=first_supply.distributor_code,
        date_from="2024/01",
        date_to="2024/12"
    )

Comparación con API V1:

# V1: Lista simple, falla completamente si hay errores
# supplies_v1 = client_v1.get_supplies()  # List[SupplyData] o excepción

# V2: Respuesta estructurada con manejo de errores granular
response_v2 = client_v2.get_supplies()  # SuppliesResponse siempre

print("Diferencias V1 vs V2:")
print(f"- V1: Todo o nada ({len(response_v2.supplies)} suministros)")
print(f"- V2: Datos + errores ({len(response_v2.distributor_error)} errores)")
print(f"- V2: Información diagnóstica disponible")

Parámetros:

supplies (List[SupplyData]) – Lista de objetos SupplyData validados con Pydantic. Contiene todos los puntos de suministro obtenidos exitosamente de los distribuidores que respondieron correctamente
distributor_error (List[DistributorError]) – Lista de errores específicos por distribuidor. Incluye información detallada sobre distribuidores que experimentaron problemas durante la consulta
data (Any)

Muestra:

ValidationError – Si la estructura de la respuesta no es válida

Nota

Una respuesta puede contener datos válidos en supplies incluso si distributor_error no está vacío. Evalúe ambos campos independientemente.

Truco

Para aplicaciones robustas, implemente lógica de filtrado que excluya suministros de distribuidores con errores de las consultas posteriores.

Ver también

SupplyData - Modelo individual de punto de suministro
DistributorError - Información detallada de errores por distribuidor
SimpleDatadisClientV2.get_supplies() - Método que retorna este modelo

Added in version 2.0: Respuesta estructurada con manejo robusto de errores por distribuidor

model_config: ClassVar[ConfigDict] = {'populate_by_name': True, 'validate_by_alias': True, 'validate_by_name': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

supplies: List[SupplyData]

distributor_error: List[DistributorError]

class datadis_python.ContractResponse(**data)[fuente]

Bases: BaseModel

Modelo Pydantic para respuesta estructurada del endpoint get-contract-detail V2.

Respuesta completa del endpoint get_contract_detail que incluye información contractual detallada y manejo robusto de errores por distribuidor. Proporciona datos contractuales completos incluso cuando algunos distribuidores experimentan problemas técnicos.

Información contractual incluida:

Datos básicos: CUPS, distribuidor, comercializadora
Información técnica: Tensión, potencias, tarifa de acceso
Autoconsumo: Configuración completa de generación renovable
Histórico: Períodos de propiedad, cambios de comercializadora

Ejemplo

Análisis de contratos con manejo de errores:

with SimpleDatadisClientV2("12345678A", "password") as client:
    response = client.get_contract_detail(
        cups="ES001234567890123456AB",
        distributor_code="2"
    )

if response.contract:
    contract = response.contract[0]
    print(f"Tarifa: {contract.code_fare}")
    print(f"Potencia: {contract.contracted_power_kw} kW")

    if contract.self_consumption_type_desc:
        print(f"Autoconsumo: {contract.self_consumption_type_desc}")

for error in response.distributor_error:
    print(f"Error en {error.distributor_name}: {error.error_description}")

Parámetros:

contract (List[ContractData]) – Lista de objetos ContractData con información contractual completa
distributor_error (List[DistributorError]) – Lista de errores específicos por distribuidor
data (Any)

model_config: ClassVar[ConfigDict] = {'populate_by_name': True, 'validate_by_alias': True, 'validate_by_name': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

contract: List[ContractData]

distributor_error: List[DistributorError]

class datadis_python.ConsumptionResponse(**data)[fuente]

Bases: BaseModel

Modelo Pydantic para respuesta estructurada del endpoint get-consumption-data V2.

Respuesta robusta del endpoint get_consumption que incluye datos de consumo energético detallados y manejo granular de errores por distribuidor. Permite análisis de consumo incluso con problemas parciales en algunos distribuidores.

Datos de consumo incluidos:

Mediciones temporales: Consumos horarios o cuarto-horarios
Autoconsumo: Generación, autoconsumo y excedentes (si aplica)
Calidad de datos: Métodos de obtención (Real/Estimada)
Períodos completos: Rangos de fechas solicitados

Ejemplo

Análisis de consumo con datos robustos:

response = client.get_consumption(
    cups="ES001234567890123456AB",
    distributor_code="2",
    date_from="2024/01",
    date_to="2024/03"
)

print(f"Mediciones obtenidas: {len(response.time_curve)}")

# Análisis básico
total_consumption = sum(data.consumption_kwh for data in response.time_curve)
print(f"Consumo total: {total_consumption:.2f} kWh")

# Verificar errores
if response.distributor_error:
    print("Advertencias de distribuidor detectadas")

Parámetros:

time_curve (List[ConsumptionData]) – Lista de objetos ConsumptionData con mediciones energéticas temporales
distributor_error (List[DistributorError]) – Lista de errores específicos por distribuidor
data (Any)

model_config: ClassVar[ConfigDict] = {'populate_by_name': True, 'validate_by_alias': True, 'validate_by_name': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

time_curve: List[ConsumptionData]

distributor_error: List[DistributorError]

class datadis_python.MaxPowerResponse(**data)[fuente]

Bases: BaseModel

Modelo Pydantic para respuesta estructurada del endpoint get-max-power V2.

Respuesta completa del endpoint get_max_power que incluye registros de potencia máxima demandada y manejo robusto de errores por distribuidor. Esencial para análisis de eficiencia y optimización de contratos eléctricos.

Datos de potencia incluidos:

Picos de demanda: Registros de potencia máxima por período
Información temporal: Fechas y horas exactas de los picos
Períodos tarifarios: Clasificación por franjas horarias (PUNTA/VALLE/LLANO)
Análisis histórico: Tendencias de consumo de potencia

Ejemplo

Optimización de contrato basada en potencias máximas:

response = client.get_max_power(
    cups="ES001234567890123456AB",
    distributor_code="2",
    date_from="2024/01",
    date_to="2024/12"
)

if response.max_power:
    max_peak = max(data.max_power for data in response.max_power)
    print(f"Pico máximo anual: {max_peak/1000:.2f} kW")

    # Recomendar potencia contratada
    recommended_power = max_peak * 1.1  # 10% de margen
    print(f"Potencia recomendada: {recommended_power/1000:.2f} kW")

Parámetros:

max_power (List[MaxPowerData]) – Lista de objetos MaxPowerData con registros de potencia máxima
distributor_error (List[DistributorError]) – Lista de errores específicos por distribuidor
data (Any)

model_config: ClassVar[ConfigDict] = {'populate_by_name': True, 'validate_by_alias': True, 'validate_by_name': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

max_power: List[MaxPowerData]

distributor_error: List[DistributorError]