buildingdata 0.2.2__tar.gz → 0.4.0__tar.gz

{buildingdata-0.2.2 → buildingdata-0.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: buildingdata
-Version: 0.2.2
+Version: 0.4.0
 Summary: Data management layer for buildingmodel — reference data download, BDTOPO retrieval, ERA5 weather
 License-Expression: MIT
 Requires-Python: >=3.10
@@ -19,6 +19,9 @@ Requires-Dist: xarray>=2023.0; extra == "era5"
 Requires-Dist: pvlib>=0.10; extra == "era5"
 Requires-Dist: netcdf4>=1.6; extra == "era5"
 Requires-Dist: zarr>=2.18; extra == "era5"
+Requires-Dist: dask>=2024.1; extra == "era5"
+Provides-Extra: bulk
+Requires-Dist: py7zr>=0.20; extra == "bulk"
 Provides-Extra: pipeline
 Requires-Dist: snakemake>=8.0; extra == "pipeline"
 Requires-Dist: openpyxl>=3.0; extra == "pipeline"
@@ -86,6 +89,38 @@ Reference datasets are pulled from a public Google Cloud Storage bucket and
 cached locally with generation-based freshness checks. French geospatial data
 uses CRS **EPSG:2154 (Lambert-93)**.
 
+## Bulk prefetch for large-scale simulations
+
+The live APIs fetch one IRIS or one grid point at a time. For campaigns over
+thousands of IRIS, prefetch whole years and départements into the local cache
+once, then read them lock-free from any number of parallel workers:
+
+```bash
+buildingdata configure --cds-key YOUR-CDS-KEY   # ERA5 needs Copernicus CDS credentials
+buildingdata prefetch era5   --years 2019       # ~1.5 GB/year; one Zarr store over metropolitan France
+buildingdata prefetch bdtopo --departments 75 92  # IGN 7z -> per-département GeoParquet
+buildingdata cache info                          # sizes + completed bulk partitions
+```
+
+```python
+import buildingdata as bd
+
+# After the prefetch, the same functions read the bulk cache automatically:
+buildings = bd.get_bdtopo("751010101")                 # source="auto" by default
+frame     = bd.get_era5_frame(48.85, 2.35, year=2019)  # EPW-format DataFrame, no EPW file
+
+# Many IRIS at once — one partition scan + spatial join per département
+frames = bd.get_bdtopo_bulk(["751010101", "751010102", "920020101"])
+
+# Or force the local cache (fails fast instead of hitting the network):
+buildings = bd.get_bdtopo("751010101", source="bulk")
+```
+
+BDTOPO bulk prefetch needs the `bulk` extra (`pip install "buildingdata[bulk]"`),
+ERA5 the `era5` extra. See the documentation page *Bulk prefetch for
+large-scale simulations* for source selection (`"auto"`/`"bulk"`/`"wfs"`/`"cds"`),
+disk sizes, concurrency guarantees and BDTOPO vintage notes.
+
 ## Configuration
 
 Settings are resolved in the following precedence order:
@@ -119,6 +154,7 @@ Because `~/.config/buildingdata/config.ini` is stored in your home directory, co
 
 ```bash
 pip install "buildingdata[era5]"   # ERA5 weather (cdsapi, xarray, pvlib, ...)
+pip install "buildingdata[bulk]"   # BDTOPO bulk prefetch (py7zr)
 pip install "buildingdata[docs]"   # build the Sphinx documentation
 ```
 

{buildingdata-0.2.2 → buildingdata-0.4.0}/README.md

@@ -53,6 +53,38 @@ Reference datasets are pulled from a public Google Cloud Storage bucket and
 cached locally with generation-based freshness checks. French geospatial data
 uses CRS **EPSG:2154 (Lambert-93)**.
 
+## Bulk prefetch for large-scale simulations
+
+The live APIs fetch one IRIS or one grid point at a time. For campaigns over
+thousands of IRIS, prefetch whole years and départements into the local cache
+once, then read them lock-free from any number of parallel workers:
+
+```bash
+buildingdata configure --cds-key YOUR-CDS-KEY   # ERA5 needs Copernicus CDS credentials
+buildingdata prefetch era5   --years 2019       # ~1.5 GB/year; one Zarr store over metropolitan France
+buildingdata prefetch bdtopo --departments 75 92  # IGN 7z -> per-département GeoParquet
+buildingdata cache info                          # sizes + completed bulk partitions
+```
+
+```python
+import buildingdata as bd
+
+# After the prefetch, the same functions read the bulk cache automatically:
+buildings = bd.get_bdtopo("751010101")                 # source="auto" by default
+frame     = bd.get_era5_frame(48.85, 2.35, year=2019)  # EPW-format DataFrame, no EPW file
+
+# Many IRIS at once — one partition scan + spatial join per département
+frames = bd.get_bdtopo_bulk(["751010101", "751010102", "920020101"])
+
+# Or force the local cache (fails fast instead of hitting the network):
+buildings = bd.get_bdtopo("751010101", source="bulk")
+```
+
+BDTOPO bulk prefetch needs the `bulk` extra (`pip install "buildingdata[bulk]"`),
+ERA5 the `era5` extra. See the documentation page *Bulk prefetch for
+large-scale simulations* for source selection (`"auto"`/`"bulk"`/`"wfs"`/`"cds"`),
+disk sizes, concurrency guarantees and BDTOPO vintage notes.
+
 ## Configuration
 
 Settings are resolved in the following precedence order:
@@ -86,6 +118,7 @@ Because `~/.config/buildingdata/config.ini` is stored in your home directory, co
 
 ```bash
 pip install "buildingdata[era5]"   # ERA5 weather (cdsapi, xarray, pvlib, ...)
+pip install "buildingdata[bulk]"   # BDTOPO bulk prefetch (py7zr)
 pip install "buildingdata[docs]"   # build the Sphinx documentation
 ```
 

{buildingdata-0.2.2 → buildingdata-0.4.0}/buildingdata/__init__.py

@@ -11,7 +11,14 @@ from .reference import (
     get_occupant_diaries,
     get_ore,
 )
-from .simulation import get_bdtopo, get_era5_climate
+from .simulation import (
+    get_bdtopo,
+    get_bdtopo_bulk,
+    get_era5_climate,
+    get_era5_frame,
+    prefetch_bdtopo,
+    prefetch_era5,
+)
 
 
 def configure(bucket=None, cache_dir=None, credentials=None):

buildingdata-0.4.0/buildingdata/_cli.py

@@ -0,0 +1,172 @@
+# -*- coding: utf-8 -*-
+import argparse
+
+from .config import write_config
+
+# Heavy modules (geopandas, xarray, ...) are imported lazily inside the
+# subcommand handlers, so `buildingdata configure` works even without the
+# era5/bulk extras installed.
+
+
+def _human_size(num_bytes):
+    """Return a human-readable size string for a byte count."""
+    size = float(num_bytes)
+    for unit in ("B", "KiB", "MiB", "GiB"):
+        if size < 1024:
+            return f"{size:.0f} {unit}" if unit == "B" else f"{size:.1f} {unit}"
+        size /= 1024
+    return f"{size:.1f} TiB"
+
+
+def _dir_size(path):
+    """Return the total size in bytes of the files under ``path``."""
+    if not path.is_dir():
+        return 0
+    return sum(p.stat().st_size for p in path.rglob("*") if p.is_file())
+
+
+def _print_prefetch_summary(results):
+    """Print the batch summary of a prefetch run and return the exit code.
+
+    Args:
+        results (dict[str, str]): partition key -> "done" | "skipped" |
+            "failed: <error>" as returned by the prefetch functions.
+
+    Returns:
+        int: 1 if any partition failed, else 0.
+    """
+    done = sum(1 for s in results.values() if s == "done")
+    skipped = sum(1 for s in results.values() if s == "skipped")
+    failed = {k: v for k, v in results.items() if v.startswith("failed")}
+    print(f"Summary: {done} done, {skipped} skipped, {len(failed)} failed")
+    for key, message in failed.items():
+        print(f"  {key}: {message}")
+    return 1 if failed else 0
+
+
+def _cmd_prefetch_era5(args):
+    from .simulation.era5_bulk import prefetch_era5
+
+    results = prefetch_era5(args.years, force=args.force)
+    return _print_prefetch_summary(results)
+
+
+def _cmd_prefetch_bdtopo(args):
+    from .simulation.bdtopo_bulk import prefetch_bdtopo
+
+    departments = None if args.all_departments else args.departments
+    results = prefetch_bdtopo(
+        departments=departments,
+        force=args.force,
+        keep_archives=args.keep_archives,
+    )
+    return _print_prefetch_summary(results)
+
+
+def _cmd_cache_info():
+    from .bulk import read_manifest
+    from .config import get_cache_dir
+
+    cache_dir = get_cache_dir()
+    print(f"Cache directory: {cache_dir}")
+    print("Disk usage:")
+    for subdir in ("era5", "era5/bulk", "bdtopo", "bdtopo/bulk"):
+        print(f"  {subdir}: {_human_size(_dir_size(cache_dir / subdir))}")
+
+    era5_years = sorted(
+        key
+        for key, entry in read_manifest("era5").items()
+        if isinstance(entry, dict) and entry.get("status") == "complete"
+    )
+    print(f"Bulk ERA5 years complete: {', '.join(era5_years) if era5_years else 'none'}")
+
+    bdtopo_entries = {
+        key: entry
+        for key, entry in read_manifest("bdtopo").items()
+        if isinstance(entry, dict) and entry.get("status") == "complete"
+    }
+    if bdtopo_entries:
+        print(f"Bulk BDTOPO départements complete ({len(bdtopo_entries)}):")
+        for dep in sorted(bdtopo_entries):
+            vintage = bdtopo_entries[dep].get("vintage", "unknown vintage")
+            print(f"  {dep}: {vintage}")
+    else:
+        print("Bulk BDTOPO départements complete: none")
+    return 0
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        prog="buildingdata",
+        description="Configure the buildingdata package and manage its local cache.",
+    )
+    sub = parser.add_subparsers(dest="command")
+
+    cfg_parser = sub.add_parser("configure", help="Write ~/.config/buildingdata/config.ini")
+    cfg_parser.add_argument("--bucket", default=None, help="GCS bucket name")
+    cfg_parser.add_argument("--cache-dir", default=None, dest="cache_dir", help="Local cache directory")
+    cfg_parser.add_argument("--credentials", default=None, help="Path to GCS service account JSON")
+    cfg_parser.add_argument("--cds-key", default=None, dest="cds_key", help="Copernicus CDS API key")
+    cfg_parser.add_argument("--cds-url", default=None, dest="cds_url", help="Copernicus CDS API URL")
+
+    prefetch_parser = sub.add_parser(
+        "prefetch", help="Bulk-download data into the local cache for large-scale simulations"
+    )
+    prefetch_sub = prefetch_parser.add_subparsers(dest="target")
+
+    era5_parser = prefetch_sub.add_parser(
+        "era5", help="Prefetch France-wide yearly ERA5 stores from the Copernicus CDS"
+    )
+    era5_parser.add_argument(
+        "--years", nargs="+", type=int, required=True, metavar="YEAR", help="Calendar years to prefetch"
+    )
+    era5_parser.add_argument("--force", action="store_true", help="Rebuild years already complete")
+
+    bdtopo_parser = prefetch_sub.add_parser(
+        "bdtopo", help="Prefetch per-département BDTOPO building partitions from IGN"
+    )
+    scope = bdtopo_parser.add_mutually_exclusive_group(required=True)
+    scope.add_argument(
+        "--departments", nargs="+", default=None, metavar="DEP",
+        help='Département codes, e.g. 75 92 2A',
+    )
+    scope.add_argument(
+        "--all", action="store_true", dest="all_departments",
+        help="All metropolitan départements",
+    )
+    bdtopo_parser.add_argument("--force", action="store_true", help="Rebuild départements already complete")
+    bdtopo_parser.add_argument(
+        "--keep-archives", action="store_true", dest="keep_archives",
+        help="Keep the downloaded 7z archives after conversion",
+    )
+
+    cache_parser = sub.add_parser("cache", help="Inspect the local cache")
+    cache_sub = cache_parser.add_subparsers(dest="action")
+    cache_sub.add_parser("info", help="Print cache location, disk usage and bulk partition status")
+
+    args = parser.parse_args()
+
+    if args.command == "configure":
+        write_config(
+            bucket=args.bucket,
+            cache_dir=args.cache_dir,
+            credentials=args.credentials,
+            cds_key=args.cds_key,
+            cds_url=args.cds_url,
+        )
+        print("Configuration saved.")
+        return 0
+    if args.command == "prefetch":
+        if args.target == "era5":
+            return _cmd_prefetch_era5(args)
+        if args.target == "bdtopo":
+            return _cmd_prefetch_bdtopo(args)
+        prefetch_parser.print_help()
+        return 2
+    if args.command == "cache":
+        if args.action == "info":
+            return _cmd_cache_info()
+        cache_parser.print_help()
+        return 2
+    parser.print_help()
+    return 0

buildingdata-0.4.0/buildingdata/bulk.py

@@ -0,0 +1,138 @@
+# -*- coding: utf-8 -*-
+"""Shared per-domain JSON manifests for bulk-prefetched cache partitions.
+
+Each bulk domain (``era5``, ``bdtopo``) keeps a single manifest file at
+``<cache>/<domain>/bulk/manifest.json`` describing its finished partitions
+(one entry per year or per departement). The concurrency contract is:
+
+- **Reads are lock-free.** The manifest is always published with an atomic
+  ``Path.replace``, so any reader sees a consistent snapshot without taking
+  a lock.
+- **Writes are serialized** with :func:`buildingdata.cache.file_lock` on a
+  ``manifest.lock`` sibling (writers are rare: prefetch runs only).
+- **Ordering rule:** a data partition is finalized (atomic rename) *before*
+  its manifest entry is written. A crash between the two only causes
+  redundant re-work on the next prefetch, never a partial read.
+"""
+import json
+import os
+import uuid
+
+from .cache import ensure_subdir, file_lock
+
+_SCHEMA_VERSION = 1
+
+
+def manifest_path(domain):
+    """Return the manifest file path for a bulk domain.
+
+    Creates the ``<cache>/<domain>/bulk`` directory if absent; the manifest
+    file itself is only created by :func:`update_manifest`.
+
+    Args:
+        domain (str): bulk domain name, e.g. "era5" or "bdtopo".
+
+    Returns:
+        pathlib.Path: absolute path to ``<cache>/<domain>/bulk/manifest.json``.
+    """
+    return ensure_subdir(f"{domain}/bulk") / "manifest.json"
+
+
+def read_manifest(domain):
+    """Return the partition entries of a domain manifest, lock-free.
+
+    Safe to call concurrently with writers: the manifest is only ever
+    published via atomic replace, so this either sees the previous or the
+    new complete snapshot. A missing or unparsable manifest reads as empty
+    (the caller then treats every partition as absent).
+
+    Args:
+        domain (str): bulk domain name, e.g. "era5" or "bdtopo".
+
+    Returns:
+        dict: mapping of partition key (year string, departement code) to
+        its entry dict; ``{}`` if the manifest is absent or unparsable.
+    """
+    path = manifest_path(domain)
+    try:
+        with open(path) as f:
+            data = json.load(f)
+    except (OSError, ValueError):
+        return {}
+    partitions = data.get("partitions") if isinstance(data, dict) else None
+    return partitions if isinstance(partitions, dict) else {}
+
+
+def _write_manifest(path, partitions):
+    """Atomically write the manifest file (caller must hold the lock)."""
+    payload = {"schema_version": _SCHEMA_VERSION, "partitions": partitions}
+    pid_suffix = f".tmp.{os.getpid()}_{uuid.uuid4().hex[:6]}"
+    tmp_path = path.with_name(path.name + pid_suffix)
+    try:
+        with open(tmp_path, "w") as f:
+            json.dump(payload, f, indent=2, sort_keys=True)
+        tmp_path.replace(path)
+    finally:
+        if tmp_path.exists():
+            tmp_path.unlink(missing_ok=True)
+
+
+def update_manifest(domain, key, entry):
+    """Insert or replace one partition entry in a domain manifest.
+
+    Takes the domain's ``manifest.lock``, re-reads the manifest under the
+    lock, merges the entry and publishes the result atomically, so
+    concurrent prefetch processes never lose each other's entries.
+
+    Per the ordering rule, call this only *after* the partition's data has
+    been atomically published.
+
+    Args:
+        domain (str): bulk domain name, e.g. "era5" or "bdtopo".
+        key (str): partition key (year string, departement code).
+        entry (dict): manifest entry, e.g. ``{"status": "complete", ...}``.
+    """
+    path = manifest_path(domain)
+    lock_file = path.with_name("manifest.lock")
+    with file_lock(lock_file):
+        partitions = read_manifest(domain)
+        partitions[str(key)] = entry
+        _write_manifest(path, partitions)
+
+
+def remove_manifest_entry(domain, key):
+    """Remove one partition entry from a domain manifest, if present.
+
+    Used before rebuilding a partition (``force=True``) so readers never see
+    a "complete" entry pointing at data that is being replaced. No-op when
+    the key is absent.
+
+    Args:
+        domain (str): bulk domain name, e.g. "era5" or "bdtopo".
+        key (str): partition key (year string, departement code).
+    """
+    path = manifest_path(domain)
+    lock_file = path.with_name("manifest.lock")
+    with file_lock(lock_file):
+        partitions = read_manifest(domain)
+        if str(key) not in partitions:
+            return
+        del partitions[str(key)]
+        _write_manifest(path, partitions)
+
+
+def partition_complete(domain, key):
+    """Return True when a partition's manifest entry reports it complete.
+
+    Lock-free (see :func:`read_manifest`). Callers that need the data itself
+    should additionally check that the partition's files exist on disk.
+
+    Args:
+        domain (str): bulk domain name, e.g. "era5" or "bdtopo".
+        key (str): partition key (year string, departement code).
+
+    Returns:
+        bool: True if the entry exists with ``"status": "complete"``.
+    """
+    entry = read_manifest(domain).get(str(key))
+    return isinstance(entry, dict) and entry.get("status") == "complete"

{buildingdata-0.2.2 → buildingdata-0.4.0}/buildingdata/config.py

@@ -94,14 +94,40 @@ def get_credentials_file():
     return Path(raw) if raw else None
 
 
-def write_config(bucket=None, cache_dir=None, credentials=None):
+def get_cds_credentials():
+    """Return Copernicus CDS API credentials as a (url, key) tuple.
+
+    Either element is None when not configured; a (None, None) result means
+    cdsapi should fall back to its own ~/.cdsapirc file.
+
+    Precedence: CDS_API_KEY / CDS_API_URL env vars → config file → None.
+
+    Returns:
+        tuple: (url or None, key or None) for building a cdsapi.Client.
+    """
+    key = os.environ.get("CDS_API_KEY")
+    url = os.environ.get("CDS_API_URL")
+    cfg = _read_config()
+    if key is None:
+        key = cfg.get("cds", "key", fallback=None)
+    if url is None:
+        url = cfg.get("cds", "url", fallback=None)
+    return url, key
+
+
+def write_config(bucket=None, cache_dir=None, credentials=None, cds_key=None, cds_url=None):
     """Write or update ~/.config/buildingdata/config.ini.
 
+    Existing sections and values not addressed by the given arguments are
+    preserved.
+
     Args:
         bucket (str, optional): GCS bucket name.
         cache_dir (str or pathlib.Path, optional): local cache directory.
         credentials (str or pathlib.Path, optional): path to GCS service
             account JSON. Pass None to leave unchanged.
+        cds_key (str, optional): Copernicus CDS API key ([cds] key).
+        cds_url (str, optional): Copernicus CDS API URL ([cds] url).
     """
     _CONFIG_FILE.parent.mkdir(parents=True, exist_ok=True)
     cfg = _read_config()
@@ -115,5 +141,12 @@ def write_config(bucket=None, cache_dir=None, credentials=None):
         cfg.set("gcs", "credentials", str(credentials))
     if cache_dir is not None:
         cfg.set("cache", "dir", str(cache_dir))
+    if cds_key is not None or cds_url is not None:
+        if not cfg.has_section("cds"):
+            cfg.add_section("cds")
+        if cds_key is not None:
+            cfg.set("cds", "key", cds_key)
+        if cds_url is not None:
+            cfg.set("cds", "url", cds_url)
     with open(_CONFIG_FILE, "w") as f:
         cfg.write(f)

buildingdata-0.4.0/buildingdata/reference/diagnosis.py

@@ -0,0 +1,108 @@
+# -*- coding: utf-8 -*-
+import polars as pl
+
+from ..gcs import download_blob, ensure_blob_cached, get_blob
+from ..validation import require_columns
+
+
+_BLOB_NAME = "energy_performance_diagnosis_latest.parquet"
+
+
+# Heating/DHW energies excluded from inference (no meaningful DPE data for coal)
+_EXCLUDED_ENERGIES = ["Charbon"]
+
+# Columns this accessor operates on directly (coal filter + dtype casts). If any
+# is absent the raw polars error is opaque; validating up front names the DPE
+# schema drift explicitly. ``heating_system`` + ``region`` are the join keys
+# ``buildingmodel``'s energy-system inference keys on; ``backup_heating_energy``
+# / ``dhw_energy`` carry the fuel labels the coal filter reads.
+_REQUIRED_COLUMNS = (
+    "heating_system",
+    "region",
+    "backup_heating_energy",
+    "dhw_energy",
+)
+
+
+def get_diagnosis(refresh=False):
+    """Return the cleaned DPE energy performance diagnosis DataFrame.
+
+    Downloads energy_performance_diagnosis_latest.parquet from GCS on first
+    call. Applies the filtering and type casts that previously lived in
+    buildingmodel/io/diagnosis.py so that buildingmodel receives a clean frame.
+
+    One row is one post-reform DPE record (issued on or after 1 July 2022), not
+    one dwelling of the stock: records are matched to buildings by
+    ``buildingmodel``, so every column is intensive — a ratio, a U-value, a rate
+    or a per-m² quantity — and carries over regardless of the building's size.
+
+    Args:
+        refresh (bool): force re-download even if the cache is warm.
+            Defaults to False.
+
+    Returns:
+        polars.DataFrame: DPE records. Beyond the matching keys
+            (``construction_year_class``, ``residential_type``,
+            ``heating_system``, and the ``district``/``city``/``city_group``/
+            ``department``/``region`` geography) the columns group as:
+
+            * envelope — ``wall_u_value``, ``roof_u_value``, ``floor_u_value``,
+              ``wall_window_u_value``, ``wall_window_share``,
+              ``envelope_u_value`` (whole-envelope Ubat),
+              ``thermal_bridge_linear_loss``, ``thermal_bridge_loss_share``,
+              ``air_change_rate``, ``air_permeability``, ``storey_height``,
+              ``inertia_class``, ``{wall,roof,floor}_insulation_type``;
+            * systems — ``main_heating_energy``, ``backup_heating_energy``,
+              ``dhw_energy``, ``heating_mode``/``dhw_mode`` (individual /
+              collective / mixed), the ``*_efficiency`` and ``*_scop`` pairs,
+              ``intermittency_factor``, ``backup_heating_share``,
+              ``dhw_storage_volume``;
+            * observed performance — ``energy_class``, ``ghg_class`` and the
+              ``annual_*_per_area`` intensities, for calibrating simulated
+              output against the diagnosis itself.
+
+            ``main_heating_system_efficiency`` is a combustion efficiency (≤ 1)
+            and is **null for heat pumps**, which have no such value; their
+            seasonal performance is in ``main_heating_system_scop`` instead
+            (null for every other generator). The same split applies to the
+            ``backup_heating_*`` pair. Treating a SCOP as an efficiency
+            understates heat-pump performance roughly threefold, hence the two
+            columns.
+
+    Raises:
+        RemoteNotAvailableError: if the blob is not found in the GCS bucket.
+        SchemaValidationError: if the fetched frame is missing one of the
+            columns this accessor operates on (see ``_REQUIRED_COLUMNS``).
+    """
+    dest = ensure_blob_cached(
+        _BLOB_NAME, refresh=refresh, get_blob_fn=get_blob, download_blob_fn=download_blob
+    )
+
+
+    df = pl.read_parquet(dest)
+
+
+    require_columns(df, _REQUIRED_COLUMNS, "DPE/EPC diagnosis")
+
+    # Remove records with coal heating/DHW — no useful inference data.
+    # ``fill_null(False)`` is load-bearing: ``backup_heating_energy`` is null for
+    # the ~76% of records with no secondary generator, ``is_in`` returns null for
+    # those, and ``filter`` drops null rows. Without it this filter keeps only
+    # dwellings that happen to own a backup system — a heavily biased subsample —
+    # instead of dropping the few hundred coal records it is meant to remove.
+    df = df.filter(
+        ~pl.col("backup_heating_energy").is_in(_EXCLUDED_ENERGIES).fill_null(False)
+        & ~pl.col("dhw_energy").is_in(_EXCLUDED_ENERGIES).fill_null(False)
+    )
+
+    df = df.with_columns([
+        pl.col("heating_system").cast(pl.Categorical),
+        pl.col("region").cast(pl.Int64),
+    ])
+
+    if "living_area" in df.columns:
+        df = df.drop(["living_area"])
+    if "living_area_class" in df.columns:
+        df = df.drop(["living_area_class"])
+
+    return df

buildingdata-0.4.0/buildingdata/simulation/__init__.py

@@ -0,0 +1,5 @@
+# -*- coding: utf-8 -*-
+from .bdtopo import get_bdtopo
+from .bdtopo_bulk import get_bdtopo_bulk, prefetch_bdtopo
+from .era5 import get_era5_climate, get_era5_frame
+from .era5_bulk import prefetch_era5