ceps-api 0.1.0__py3-none-any.whl

ceps_api/__init__.py

@@ -0,0 +1,29 @@
+"""
+Czech Electrical Power Transmission system data from ČEPS.
+
+ČEPS publishes system imbalance, activated balancing energy, load and
+generation over a SOAP service. It needs no key, and is not pleasant
+to call directly. This wraps it: every method of the service has a
+wrapper of the same name on Ceps, which returns a pandas DataFrame.
+
+    from ceps_api import Ceps
+
+    ceps = Ceps()
+    df = ceps.AktualniSystemovaOdchylkaCR("2026-09-14", "2026-09-15", aggregation="QH")
+
+    Ceps.parameters()              # the methods
+    Ceps.parameters("Generation")  # what one of them accepts
+"""
+from importlib.metadata import version
+
+from .catalog import CEPS_AGGREGATIONS, CEPS_DATA_VERSIONS, CEPS_FUNCTIONS, CEPS_METHODS
+from .client import Ceps
+from .models import CepsMethod, CepsResponseType
+from .soap import CEPS_NS, CEPS_URL, CepsError
+
+# The version in pyproject.toml, as installed.
+__version__ = version("ceps-api")
+
+__all__ = ["__version__", "Ceps", "CepsError", "CEPS_NS", "CEPS_URL",
+           "CEPS_METHODS", "CepsMethod", "CepsResponseType", "CEPS_AGGREGATIONS",
+           "CEPS_FUNCTIONS", "CEPS_DATA_VERSIONS"]

ceps_api/catalog.py

@@ -0,0 +1,231 @@
+"""
+Catalog of the ČEPS service: its methods, their parameters and the aggregation, function and version values
+they take.
+
+What the parameters mean is described in the interface description that
+ČEPS publishes at https://www.ceps.cz/cs/webove-sluzby ("Popis rozhraní pro
+poskytování strukturovaných dat", version 3.2). Unfortunately the ČEPS service itself does
+not strictly follow their own document; see the notes below.
+
+Every available ČEPS method has a wrapper of the same name, which returns
+a DataFrame; Ceps.parameters() lists what each of them accepts.
+
+scripts/ceps_catalog.py writes a fresh version of this dict (for when the
+service changes) to a separate file, to be reviewed and copied over by hand:
+required_params and optional_params come from the WSDL and were verified by
+trying.
+
+Note the WSDL spells para1 without the "m" for PowerBalance, Generation
+and GenerationRES, and spells aggregation as "agregation", so beware.
+
+A value the ČEPS service does not know is not an error: everything comes back,
+or nothing does, so the wrappers check the value.
+
+Points in the ČEPS documentation which are not followed, because the
+service does not adhere to them:
+  - it gives EmergencyExchangeACER an aggregation and a function, which
+    the method does not seem to take
+  - it has mFFR+ for the mFRR+ of AktualniCenaRE (the latter is correct, a typo of F for R)
+  - it allows only AVG for CrossborderPowerFlows and ExportImportSVR; however
+    other functions work too
+  - its tables of the aggregations allowed per period are not enforced
+    (see CEPS_AGGREGATIONS). They leave out QH for GenerationPlan and YR
+    for EmergencyExchange, which both return data, and have the peak and
+    off-peak variants for PowerBalance, which return nothing
+  - it has OdhadovanaCenaOdchylky per hour; it is per quarter hour now
+  - it does not describe Emise and OfferPrices at all
+"""
+
+from __future__ import annotations
+
+from .models import CepsMethod, CepsResponseType
+
+#----------------------------------------------------------------------------------------------------------------------------
+CEPS_METHODS = {
+    "AktivaceSVRvCR": CepsMethod(
+        "Activated balancing energy (aFRR+/-, mFRR+/-, mFRR5), [MW]",
+        optional_params=("agregation", "function", "param1"),
+        aggregations=("MI", "QH", "HR", "DY"),
+        param_values={"param1": ("all", "aFRR+", "aFRR-", "mFRR+", "mFRR-", "RR+", "RR-", "mFRR5")},
+    ),
+    "AktualniCenaRE": CepsMethod(
+        "Price of activated regulating energy (aFRR, mFRR+/-, mFRR5), [EUR/MWh]",
+        optional_params=("param1",),
+        param_values={"param1": ("All", "aFRR", "mFRR+", "mFRR-", "mFRR5")},
+    ),
+    "AktualniSystemovaOdchylkaCR": CepsMethod(
+        "Current system imbalance of the Czech control area, [MW]",
+        optional_params=("agregation", "function"),
+        aggregations=("MI", "QH", "HR"),
+    ),
+    "CrossborderPowerFlows": CepsMethod(
+        "Actual and planned flows per neighbouring operator, [MW]",
+        optional_params=("agregation", "function", "version"),
+        needed_params=("agregation", "function"),
+        aggregations=("MI", "QH", "HR", "DY", "WE", "MO", "YR"),
+        versions=("RT",),
+    ),
+    "DataAgregation": CepsMethod(
+        "Lists the aggregation codes. Not a time series",
+        required_params=(),
+        response_type=CepsResponseType.CODES,
+    ),
+    "DataVersion": CepsMethod(
+        "Lists the version codes. Not a time series",
+        required_params=(),
+        response_type=CepsResponseType.CODES,
+    ),
+    "EmergencyExchange": CepsMethod(
+        "Emergency assistance, redispatch and regulating energy from abroad, a row per border and direction. Only has rows when something happened",
+        optional_params=("agregation", "function", "version", "param1", "param2"),
+        needed_params=("agregation", "function", "version"),
+        aggregations=("QH", "HR", "DY", "DYO", "DYP", "WE", "WEO", "WEP", "MO", "MOO", "MOP", "YR", "YRO", "YRP"),
+        versions=("RT",),
+        param_values={"param1": ("All", "E", "R"), "param2": ("All", "APG", "SEPS", "TenneT", "PSE", "50HzT")},
+        response_type=CepsResponseType.TABLE,
+    ),
+    "EmergencyExchangeACER": CepsMethod(
+        "Emergency exchange as an ACER message. Not a time series",
+        optional_params=("param1", "param2"),
+        param_values={"param1": ("All", "E", "R"), "param2": ("All", "APG", "SEPS", "TenneT", "PSE", "50HzT")},
+        response_type=CepsResponseType.MESSAGE,
+    ),
+    "Emise": CepsMethod(
+        "CO2 intensity of generation, [g CO2/kWh]. Always per quarter hour, the service ignores the aggregation",
+        optional_params=("agregation", "function", "version", "param1"),
+        needed_params=("version",),
+        aggregations=("QH",),
+        versions=("RT",),
+    ),
+    "ExportImportSVR": CepsMethod(
+        "Exchange with the European balancing platforms (imbalance netting, MARI, PICASSO)",
+        optional_params=("agregation", "function", "param1"),
+        aggregations=("MI", "QH", "HR", "DY"),
+        param_values={"param1": ("PcorrHVNCER", "PcorrImbalanceNetting", "PcorrMari", "PcorrPicasso", "VYKON")},
+    ),
+    "ExportImportVykonu": CepsMethod(
+        "Export (+) and import (-) of power within the European platforms and foreign assistance, [MW]. Data from 2022-05-20 to 2023-08-25, then ExportImportSVR",
+        optional_params=("agregation", "function"),
+        aggregations=("MI", "QH", "HR", "DY"),
+    ),
+    "Frekvence": CepsMethod(
+        "System frequency, [Hz]",
+    ),
+    "Generation": CepsMethod(
+        "Gross generation by plant type, [MW]",
+        optional_params=("agregation", "function", "version", "para1"),
+        needed_params=("agregation", "function", "version", "para1"),
+        aggregations=("QH", "HR", "DY", "DYO", "DYP", "WE", "WEO", "WEP", "MO", "MOO", "MOP", "YR", "YRO", "YRP"),
+        versions=("RT",),
+        param_values={"para1": ("all", "AE", "JE", "PE", "PPE", "PVE", "VE", "ZE", "VTE", "FVE")},
+    ),
+    "GenerationPlan": CepsMethod(
+        "Planned gross generation, [MW]",
+        optional_params=("agregation", "function", "version"),
+        needed_params=("agregation", "function", "version"),
+        aggregations=("QH", "HR", "DY", "DYO", "DYP", "WE", "WEO", "WEP", "MO", "MOO", "MOP", "YR", "YRO", "YRP"),
+        versions=("RT",),
+    ),
+    "GenerationRES": CepsMethod(
+        "Estimated wind and solar generation, [MW]",
+        optional_params=("agregation", "function", "version", "para1"),
+        needed_params=("agregation", "function", "version", "para1"),
+        aggregations=("MI", "QH", "HR", "DY", "DYO", "DYP", "WE", "WEO", "WEP", "MO", "MOO", "MOP", "YR", "YRO", "YRP"),
+        versions=("RT",),
+        param_values={"para1": ("all", "VTE", "FVE")},
+    ),
+    "Load": CepsMethod(
+        "Load with and without pumping, [MW]; load is gross generation + import - export - pumping. The forecast versions have it without pumping only",
+        optional_params=("agregation", "function", "version"),
+        needed_params=("agregation", "function", "version"),
+        aggregations=("MI", "QH", "HR", "DY", "DYO", "DYP", "WE", "WEO", "WEP", "MO", "MOO", "MOP", "YR", "YRO", "YRP"),
+        versions=("RT", "DR", "DF", "WF", "MF", "YF"),
+    ),
+    "MaximalniCenySVRnaDT": CepsMethod(
+        "Maximum prices of balancing services on the day-ahead market, a row per day and currency. Data from 2022-08-26 to 2024-07-04",
+        response_type=CepsResponseType.TABLE,
+    ),
+    "NepredvidatelneOdmitnuteNabidky": CepsMethod(
+        "Unforeseeably rejected bids of one product (aFRR+ if none is given): per hour and bid the price offered [Kč] and the power not accepted [MW]",
+        optional_params=("param1",),
+        param_values={"param1": ("FCR", "aFRR+", "aFRR-", "mFRR+", "mFRR-", "mFRR5")},
+        response_type=CepsResponseType.TABLE,
+    ),
+    "OdhadovanaCenaOdchylky": CepsMethod(
+        "Estimated imbalance price, [Kč/MWh]. Not a plain time series",
+        response_type=CepsResponseType.ESTIMATED_PRICE,
+    ),
+    "OfferPrices": CepsMethod(
+        "Offer prices of regulating energy: per hour and bid the price [Kč] and the power [MW]. Data from November 2017 to 2022-03-31",
+        optional_params=("version", "param1"),
+        response_type=CepsResponseType.TABLE,
+    ),
+    "PowerBalance": CepsMethod(
+        "Yearly forecast of the power balance: domestic sources, outages, reserve of ancillary services and load, [MW]",
+        optional_params=("agregation", "function", "version", "para1"),
+        needed_params=("agregation", "function", "version", "para1"),
+        aggregations=("WE", "YR"),
+        versions=("YF",),
+        param_values={"para1": ("all", "BALANCE", "TDGENCAP", "TOUTAGES", "SYSSERVR", "LOAD")},
+    ),
+}
+#----------------------------------------------------------------------------------------------------------------------------
+"""
+Values for aggregation.
+Which codes a method supports differs, see CepsMethod.aggregations; a code it does
+not support gives an empty document, not an error.
+
+A time step comes back when it starts between dateFrom and dateTo, both
+included, and it always covers the whole step, whichever part of it the
+period asks for. So a period has to hold the start of a step to get it:
+1 January for YR, the first of the month for MO.
+
+WE and WEO are wrong around the clock changes. For the week in which the
+clocks go forward the service returns several rows, none of them the mean
+of that week, which the wrappers refuse with a CepsError; the week after
+lacks its first hour and the week of the change in autumn is slightly off
+too. The days and months there (DY, MO) are right.
+"""
+CEPS_AGGREGATIONS = {
+    "MI": "minute",
+    "QH": "quarter hour",
+    "HR": "hour",
+    "DY": "day",
+    "DYO": "day off-peak",
+    "DYP": "day peak",
+    "WE": "week",
+    "WEO": "week off-peak",
+    "WEP": "week peak",
+    "MO": "month",
+    "MOO": "month off-peak",
+    "MOP": "month peak",
+    "YR": "year",
+    "YRO": "year off-peak",
+    "YRP": "year peak",
+}
+#----------------------------------------------------------------------------------------------------------------------------
+"""
+Values for function: how the raw values are combined within one
+aggregation step.
+
+An aggregation needs a function with it: without one the service fails
+or returns rows that hold no values.
+"""
+CEPS_FUNCTIONS = ("AVG", "MIN", "MAX", "SUM")
+#----------------------------------------------------------------------------------------------------------------------------
+"""Labels for version, as listed by the DataVersion method. See ČEPS documentation for meaning"""
+CEPS_DATA_VERSIONS = {
+    "RT": "real data",
+    "DF": "daily forecast",
+    "DR": "daily revision",
+    "IDF": "intraday forecast",
+    "WF": "weekly forecast",
+    "WR": "weekly revision",
+    "MF": "monthly forecast",
+    "MR": "monthly revision",
+    "QF": "quarterly forecast",
+    "QR": "quarterly revision",
+    "YF": "yearly forecast",
+    "YR": "yearly revision",
+}
+#----------------------------------------------------------------------------------------------------------------------------

ceps_api/client.py

@@ -0,0 +1,346 @@
+"""Client for the ČEPS SOAP service, with a wrapper for each of its methods."""
+from __future__ import annotations
+
+import inspect
+from typing import Any
+
+import pandas as pd
+
+from . import soap
+from .catalog import CEPS_AGGREGATIONS, CEPS_DATA_VERSIONS, CEPS_FUNCTIONS, CEPS_METHODS
+from .convert import DateLike, to_ceps_time, to_dataframe
+from .parsing import parse
+from .soap import CepsError
+from .validation import service_name, validate
+
+
+class Ceps:
+    """
+    The ČEPS service
+
+    Every method of the service has a wrapper of the same name as
+    the ČEPS calls the method. The wrapper returns a DataFrame.
+
+    *Ceps.parameters()* lists the methods and
+    e.g. *Ceps.parameters("Generation")* lists the parameters it accepts.
+
+    *start* and *end* are Czech local time (see convert.to_ceps_time) and both are included:
+    with an *aggregation*, the steps that start between them come back, the
+    one that starts at end too. So a whole day is start="2026-10-05",
+    end="2026-10-05T23:59:00". A step that start cuts into is left out; one
+    that end cuts into comes back whole. The latest step keeps changing for
+    a few minutes after it is over, until all its minutes are in.
+
+    *aggregation* is the time step (see CEPS_AGGREGATIONS) and *function* is how
+    the values within it are combined (see CEPS_FUNCTIONS); function is only
+    sent with an aggregation.
+
+    Time series come back indexed by "timestamp", the start of the step in
+    Europe/Prague time, with a column per series as ČEPS names it.
+
+    A wrapper raises ValueError for arguments the service would not accept
+    (see validation.validate), before anything is sent, and CepsError if
+    the service fails or a SERIES method returns something that is not one
+    row per timestamp.
+    """
+    #----------------------------------------------------------------------------------------------------------------------------
+    def __init__(self, timeout: int = 30):
+        self.timeout = timeout # timeout in seconds
+    #----------------------------------------------------------------------------------------------------------------------------
+    def _fetch(self, method: str, **args: Any) -> pd.DataFrame:
+        """
+        Calls a method with the arguments of its wrapper: renames them to
+        what the service calls them, checks them, sends the request and
+        parses the answer. None arguments are left out, and so is function
+        without an aggregation.
+
+        The check gets the wrapper's names along, so that an error names
+        the argument of the wrapper (param1), not the service's (para1).
+        """
+        params: dict[str, Any] = {}
+        shown: dict[str, str] = {}
+        for name, value in args.items():
+            service = service_name(method, name)
+            # Every argument is named, a left out one is still reported as missing.
+            shown[service] = name
+            if value is not None:
+                params[service] = value
+        validate(method, params, shown)
+        # Dropped only after the check, which would otherwise report the
+        # function missing too when a needed aggregation is.
+        if "agregation" not in params:
+            params.pop("function", None)
+        for key in ("dateFrom", "dateTo"):
+            if key in params:
+                params[key] = to_ceps_time(params[key])
+        response_type = CEPS_METHODS[method].response_type
+        raw = soap.call(method, params, self.timeout)
+        try:
+            data = parse(response_type, raw)
+        except CepsError as e:
+            # The parser does not know which method it reads.
+            raise CepsError(f"{method}: {e}") from None
+        return to_dataframe(response_type, data)
+    #----------------------------------------------------------------------------------------------------------------------------
+    @staticmethod
+    def parameters(method: str | None = None) -> pd.DataFrame:
+        """
+        What the wrappers accept, for all methods or for just one.
+
+        Without *method* it gives an overview, a row per method of
+        CEPS_METHODS, indexed by "method", with the columns:
+
+          - description: what the method returns, as in the catalog
+          - arguments: the arguments of its wrapper, comma separated
+          - response_type: the shape of the answer (see CepsResponseType)
+
+        With *method* it gives a row per argument of that wrapper, indexed
+        by "parameter", with the columns:
+
+          - required: True if the wrapper has no default for it
+          - default: the wrapper's default, None for a required one
+          - allowed: the values the service accepts, comma separated, or
+            "not known" where the catalog does not list them
+
+        The arguments are read off the wrapper's signature, so they are
+        named as the wrapper names them (param1, aggregation), not as the
+        service does (para1, agregation). A method that takes no arguments,
+        e.g. DataAgregation, gives an empty frame.
+
+        Raises ValueError for a method that is not in CEPS_METHODS.
+
+        >>> Ceps.parameters()                  # every method
+        >>> Ceps.parameters("Generation")      # the arguments of one
+        """
+        if method is None:
+            # The wrapper is looked up by name, Ceps has one for every
+            # method of the catalog.
+            return pd.DataFrame(
+                [{"method": name,
+                  "description": info.description,
+                  "arguments": ", ".join(p for p in inspect.signature(getattr(Ceps, name)).parameters
+                                         if p != "self"),
+                  "response_type": info.response_type.value}
+                 for name, info in CEPS_METHODS.items()]).set_index("method")
+        if method not in CEPS_METHODS:
+            raise ValueError(f"Unknown ČEPS method {method!r}, "
+                             f"expected one of {', '.join(CEPS_METHODS)}")
+        info = CEPS_METHODS[method]
+        rows = []
+        for name, p in inspect.signature(getattr(Ceps, method)).parameters.items():
+            # Reached through the class, the wrapper still lists self.
+            if name == "self":
+                continue
+            if name in ("start", "end"):
+                # Anything convert.to_ceps_time takes.
+                allowed = "date, datetime or ISO string, Czech local time"
+            elif name == "aggregation":
+                # A method without its own list in the catalog takes any
+                # aggregation of the service.
+                allowed = ", ".join(info.aggregations or CEPS_AGGREGATIONS)
+            elif name == "function":
+                # The same for every method.
+                allowed = ", ".join(CEPS_FUNCTIONS)
+            elif name == "version":
+                # As with aggregation, no list of its own means all of them.
+                allowed = ", ".join(info.versions or CEPS_DATA_VERSIONS)
+            else:
+                # param1, param2, ...: the catalog keys their values by the
+                # service's name, which for some methods is para1, so the
+                # wrapper's name is translated first.
+                values = info.param_values.get(service_name(method, name))
+                allowed = ", ".join(values) if values else "not known"
+            # An argument without a default has to be given.
+            required = p.default is inspect.Parameter.empty
+            rows.append({"parameter": name,
+                         "required": required,
+                         "default": None if required else p.default,
+                         "allowed": allowed})
+        return pd.DataFrame(rows, columns=["parameter", "required", "default", "allowed"]).set_index("parameter")
+    #----------------------------------------------------------------------------------------------------------------------------
+    #----------------------------------------------------------------------------------------------------------------------------
+
+    # START OF WRAPPERS FOR THE SERVICE METHODS
+
+    #----------------------------------------------------------------------------------------------------------------------------
+    #----------------------------------------------------------------------------------------------------------------------------
+    def AktivaceSVRvCR(self, start: DateLike, end: DateLike, aggregation: str | None = None,
+                       function: str = "AVG", param1: str | None = None) -> pd.DataFrame:
+        """
+        Activated balancing energy in the Czech area, MW.
+
+        A column per product (aFRR+, aFRR-, mFRR+, mFRR-, mFRR5); the
+        downward ones (aFRR-, mFRR-) are negative. param1 picks one
+        product. Without an aggregation it is per minute.
+        """
+        return self._fetch("AktivaceSVRvCR", start=start, end=end, aggregation=aggregation,
+                           function=function, param1=param1)
+    #----------------------------------------------------------------------------------------------------------------------------
+    def AktualniCenaRE(self, start: DateLike, end: DateLike, param1: str | None = None) -> pd.DataFrame:
+        """
+        Price of activated regulating energy, EUR/MWh.
+
+        A column per product (aFRR, mFRR+, mFRR-, mFRR5); param1 picks
+        one.
+
+        Always per minute: the method takes no aggregation. Resample the
+        frame for quarter hours.
+        """
+        return self._fetch("AktualniCenaRE", start=start, end=end, param1=param1)
+    #----------------------------------------------------------------------------------------------------------------------------
+    def AktualniSystemovaOdchylkaCR(self, start: DateLike, end: DateLike, aggregation: str | None = None,
+                                    function: str = "AVG") -> pd.DataFrame:
+        """
+        System imbalance of the Czech control area, MW. Negative means the
+        system is short (generation below consumption).
+
+        Without an aggregation it is per minute; the minute series has
+        gaps of a few minutes a day.
+        """
+        return self._fetch("AktualniSystemovaOdchylkaCR", start=start, end=end,
+                           aggregation=aggregation, function=function)
+    #----------------------------------------------------------------------------------------------------------------------------
+    def CrossborderPowerFlows(self, start: DateLike, end: DateLike, aggregation: str = "QH",
+                              function: str = "AVG", version: str | None = None) -> pd.DataFrame:
+        """Actual and planned flows per neighbouring operator, MW."""
+        return self._fetch("CrossborderPowerFlows", start=start, end=end, aggregation=aggregation,
+                           function=function, version=version)
+    #----------------------------------------------------------------------------------------------------------------------------
+    def DataAgregation(self) -> pd.DataFrame:
+        """The aggregation codes of the service and their descriptions."""
+        return self._fetch("DataAgregation")
+    #----------------------------------------------------------------------------------------------------------------------------
+    def DataVersion(self) -> pd.DataFrame:
+        """The data version codes of the service and their descriptions."""
+        return self._fetch("DataVersion")
+    #----------------------------------------------------------------------------------------------------------------------------
+    def EmergencyExchange(self, start: DateLike, end: DateLike, aggregation: str = "QH", function: str = "AVG",
+                          version: str = "RT", param1: str | None = None,
+                          param2: str | None = None) -> pd.DataFrame:
+        """
+        Emergency assistance, redispatch and regulating energy from abroad,
+        a row per step, border and direction; only has rows when something
+        happened. param1 picks the kind (E, R), param2 the operator.
+        """
+        return self._fetch("EmergencyExchange", start=start, end=end, aggregation=aggregation,
+                           function=function, version=version, param1=param1, param2=param2)
+    #----------------------------------------------------------------------------------------------------------------------------
+    def EmergencyExchangeACER(self, start: DateLike, end: DateLike, param1: str | None = None,
+                              param2: str | None = None) -> pd.DataFrame:
+        """
+        The emergency exchange as an ACER message: one row however long
+        the period, a column per field, all text. The remarks field holds
+        the exchanges themselves, one "Direction-Type-MWh|" line each.
+        """
+        return self._fetch("EmergencyExchangeACER", start=start, end=end, param1=param1, param2=param2)
+    #----------------------------------------------------------------------------------------------------------------------------
+    def Emise(self, start: DateLike, end: DateLike, aggregation: str | None = None, function: str = "AVG",
+              version: str = "RT", param1: str | None = None) -> pd.DataFrame:
+        """
+        CO2 intensity of generation, g CO2/kWh. Always per quarter hour,
+        the service ignores the aggregation. The values of param1 are not
+        known.
+        """
+        return self._fetch("Emise", start=start, end=end, aggregation=aggregation, function=function,
+                           version=version, param1=param1)
+    #----------------------------------------------------------------------------------------------------------------------------
+    def ExportImportSVR(self, start: DateLike, end: DateLike, aggregation: str | None = None,
+                        function: str = "AVG", param1: str | None = None) -> pd.DataFrame:
+        """
+        Exchange with the European balancing platforms (imbalance netting,
+        MARI, PICASSO), MW. param1 picks one series.
+        """
+        return self._fetch("ExportImportSVR", start=start, end=end, aggregation=aggregation,
+                           function=function, param1=param1)
+    #----------------------------------------------------------------------------------------------------------------------------
+    def ExportImportVykonu(self, start: DateLike, end: DateLike, aggregation: str | None = None,
+                           function: str = "AVG") -> pd.DataFrame:
+        """
+        Export (+) and import (-) of power within the European platforms
+        and foreign assistance, MW. Data from 2022-05-20 to 2023-08-25,
+        then ExportImportSVR.
+        """
+        return self._fetch("ExportImportVykonu", start=start, end=end, aggregation=aggregation,
+                           function=function)
+    #----------------------------------------------------------------------------------------------------------------------------
+    def Frekvence(self, start: DateLike, end: DateLike) -> pd.DataFrame:
+        """System frequency, Hz."""
+        return self._fetch("Frekvence", start=start, end=end)
+    #----------------------------------------------------------------------------------------------------------------------------
+    def Generation(self, start: DateLike, end: DateLike, aggregation: str = "QH", function: str = "AVG",
+                   version: str = "RT", param1: str = "all") -> pd.DataFrame:
+        """Gross generation by plant type, MW. param1 picks one type."""
+        return self._fetch("Generation", start=start, end=end, aggregation=aggregation, function=function,
+                           version=version, param1=param1)
+    #----------------------------------------------------------------------------------------------------------------------------
+    def GenerationPlan(self, start: DateLike, end: DateLike, aggregation: str = "QH", function: str = "AVG",
+                       version: str = "RT") -> pd.DataFrame:
+        """Planned gross generation, MW."""
+        return self._fetch("GenerationPlan", start=start, end=end, aggregation=aggregation,
+                           function=function, version=version)
+    #----------------------------------------------------------------------------------------------------------------------------
+    def GenerationRES(self, start: DateLike, end: DateLike, aggregation: str = "QH", function: str = "AVG",
+                      version: str = "RT", param1: str = "all") -> pd.DataFrame:
+        """Estimated wind (VTE) and solar (FVE) generation, MW. param1 picks one."""
+        return self._fetch("GenerationRES", start=start, end=end, aggregation=aggregation,
+                           function=function, version=version, param1=param1)
+    #----------------------------------------------------------------------------------------------------------------------------
+    def Load(self, start: DateLike, end: DateLike, aggregation: str = "QH", function: str = "AVG",
+             version: str = "RT") -> pd.DataFrame:
+        """
+        Load with and without pumping, MW; load is gross generation +
+        import - export - pumping. The forecast versions have it without
+        pumping only.
+        """
+        return self._fetch("Load", start=start, end=end, aggregation=aggregation, function=function,
+                           version=version)
+    #----------------------------------------------------------------------------------------------------------------------------
+    def MaximalniCenySVRnaDT(self, start: DateLike, end: DateLike) -> pd.DataFrame:
+        """
+        Maximum prices of balancing services on the day-ahead market, a row
+        per day and currency. Data from 2022-08-26 to 2024-07-04.
+        """
+        return self._fetch("MaximalniCenySVRnaDT", start=start, end=end)
+    #----------------------------------------------------------------------------------------------------------------------------
+    def NepredvidatelneOdmitnuteNabidky(self, start: DateLike, end: DateLike,
+                                        param1: str | None = None) -> pd.DataFrame:
+        """
+        Unforeseeably rejected bids of one product (param1, aFRR+ if none
+        is given): per hour and bid the price offered (Kč) and the power
+        not accepted (MW).
+        """
+        return self._fetch("NepredvidatelneOdmitnuteNabidky", start=start, end=end, param1=param1)
+    #----------------------------------------------------------------------------------------------------------------------------
+    def OdhadovanaCenaOdchylky(self, start: DateLike, end: DateLike) -> pd.DataFrame:
+        """
+        ČEPS's estimate of the imbalance price, Kč/MWh, per quarter hour
+        (per hour for older data, e.g. 2020). A range in the future or with
+        end before start gives an empty frame.
+
+        A price of exactly 0 is common (about one interval in five) and is
+        a real value. The service ignores aggregation and function here.
+        """
+        return self._fetch("OdhadovanaCenaOdchylky", start=start, end=end)
+    #----------------------------------------------------------------------------------------------------------------------------
+    def OfferPrices(self, start: DateLike, end: DateLike, version: str | None = None,
+                    param1: str | None = None) -> pd.DataFrame:
+        """
+        Offer prices of regulating energy: per hour and bid the price (Kč)
+        and the power (MW). Data from November 2017 to 2022-03-31.
+        """
+        return self._fetch("OfferPrices", start=start, end=end, version=version, param1=param1)
+    #----------------------------------------------------------------------------------------------------------------------------
+    def PowerBalance(self, start: DateLike, end: DateLike, aggregation: str = "WE", function: str = "AVG",
+                     version: str = "YF", param1: str = "all") -> pd.DataFrame:
+        """
+        Yearly forecast of the power balance: domestic sources, outages,
+        reserve of ancillary services and load, MW. param1 picks one part.
+        """
+        return self._fetch("PowerBalance", start=start, end=end, aggregation=aggregation,
+                           function=function, version=version, param1=param1)
+#----------------------------------------------------------------------------------------------------------------------------
+
+# A method added to the catalog needs its wrapper too.
+_missing = [m for m in CEPS_METHODS if not callable(getattr(Ceps, m, None))]
+if _missing:
+    raise ImportError(f"Ceps has no wrapper for {', '.join(_missing)}")