buildstock-fetch 0.1.0__py3-none-any.whl → 1.0.0__py3-none-any.whl

buildstock_fetch/utils/ev_utils.py

@@ -0,0 +1,270 @@
+"""
+Utility functions for EV demand calculations.
+
+This module contains:
+- Census division mapping functions
+- Data loading functions for metadata, NHTS, and weather data
+"""
+
+from pathlib import Path
+from typing import Any
+
+import polars as pl
+
+__all__ = [
+    "get_census_division_for_state",
+    "load_all_input_data",
+    "load_metadata",
+    "load_metro_puma_map",
+    "load_nhts_data",
+    "load_pums_data",
+    "load_weather_data",
+]
+
+
+def get_census_division_for_state(state: str) -> int:
+    """
+    Get the census division number for a given state.
+
+    Args:
+        state: State abbreviation (e.g., "NY", "CA")
+
+    Returns:
+        Census division number (1-9)
+
+    Raises:
+        ValueError: If the state is not found in any census division
+    """
+    census_divisions = {
+        1: ["CT", "ME", "MA", "NH", "RI", "VT"],  # New England
+        2: ["NJ", "NY", "PA"],  # Middle Atlantic
+        3: ["IL", "IN", "MI", "OH", "WI"],  # East North Central
+        4: ["IA", "KS", "MN", "MO", "NE", "ND", "SD"],  # West North Central
+        5: ["DE", "DC", "FL", "GA", "MD", "NC", "SC", "VA", "WV"],  # South Atlantic
+        6: ["AL", "KY", "MS", "TN"],  # East South Central
+        7: ["AR", "LA", "OK", "TX"],  # West South Central
+        8: ["AZ", "CO", "ID", "MT", "NV", "NM", "UT", "WY"],  # Mountain
+        9: ["AK", "CA", "HI", "OR", "WA"],  # Pacific
+    }
+
+    for division, states in census_divisions.items():
+        if state in states:
+            return division
+
+    msg = f"State {state} not found in any census division"
+    raise ValueError(msg)
+
+
+def load_metadata(metadata_path: str) -> pl.DataFrame:
+    """
+    Load and parse the ResStock metadata parquet file.
+
+    Args:
+        metadata_path: Path to the metadata parquet file
+
+    Returns:
+        DataFrame with columns including 'bldg_id', 'occupants', 'income', 'metro', 'puma.
+
+    Raises:
+        FileNotFoundError: If the metadata file doesn't exist
+    """
+    if not Path(metadata_path).exists():
+        msg = f"Metadata file not found: {metadata_path}"
+        raise FileNotFoundError(msg)
+
+    metadata_df = pl.read_parquet(metadata_path)
+
+    # Select and rename columns
+    metadata_df = metadata_df.select([
+        pl.col("bldg_id"),
+        pl.col("weight"),
+        pl.col("in.puma_metro_status").alias("metro"),
+        pl.col("in.puma").alias("puma"),
+        pl.col("in.income").alias("income"),
+        pl.col("in.occupants").alias("occupants"),
+    ])
+
+    # Process household size - replace "10+" with "10" and convert to numeric
+    metadata_df = metadata_df.with_columns([
+        pl.when(pl.col("occupants") == "10+").then(pl.lit("10")).otherwise(pl.col("occupants")).alias("occupants_temp")
+    ])
+
+    # Now cast to numeric
+    metadata_df = metadata_df.with_columns([pl.col("occupants_temp").cast(pl.Int64).alias("occupants")]).drop(
+        "occupants_temp"
+    )
+
+    # Create household size bins
+    metadata_df = metadata_df.with_columns([
+        pl.when(pl.col("occupants") > 1)
+        .then(pl.lit("2+ ppl"))
+        .when(pl.col("occupants") == 1)
+        .then(pl.lit("1 person"))
+        .otherwise(pl.lit(None))
+        .alias("hhsize_bins")
+    ])
+
+    # Process income categories
+    metadata_df = metadata_df.with_columns([
+        pl.when(pl.col("income") == "<10000")
+        .then(pl.lit("0-10000"))
+        .when(pl.col("income") == "200000+")
+        .then(pl.lit("200000-500000"))
+        .when(pl.col("income") == "Not Available")
+        .then(pl.lit(None))
+        .otherwise(pl.col("income"))
+        .alias("income")
+    ])
+
+    # Extract last 5 characters from PUMA
+    metadata_df = metadata_df.with_columns([pl.col("puma").str.slice(-5).alias("puma")])
+
+    return metadata_df
+
+
+def load_nhts_data(nhts_path: str, state: str) -> pl.DataFrame:
+    """
+    Load and preprocess the NHTS trip data for a specific state.
+
+    Args:
+        nhts_path: Path to the NHTS trip data file
+        state: State abbreviation to filter data for
+
+    Returns:
+        DataFrame with trip records filtered for the specified state's census division
+    """
+    if not Path(nhts_path).exists():
+        msg = f"NHTS file not found: {nhts_path}. Please run `just download-nhts` to download the data."
+        raise FileNotFoundError(msg)
+
+    # Define the columns we need
+    needed_columns = [
+        "CENSUS_D",  # census division (needed for filtering)
+        "VEHCASEID",  # unique hh/vehicle id
+        "STRTTIME",  # start time
+        "ENDTIME",  # end time
+        "TRPMILES",  # miles driven
+        "TDWKND",  # weekday(2)/weekend(1) flag
+        "HHSIZE",  # occupants
+        "HHFAMINC",  # household income
+        "HHVEHCNT",  # total number of vehicles
+        "URBRUR",  # urban/rural status urban(1)/rural(2)
+    ]
+
+    # Load only the needed columns
+    nhts_df = pl.read_csv(nhts_path, columns=needed_columns)
+
+    # Get the census division for this state
+    state_division = get_census_division_for_state(state)
+
+    # Filter to only keep census division for this state
+    nhts_df = nhts_df.filter(pl.col("CENSUS_D") == state_division)
+
+    # Remove the CENSUS_D column since we don't need it anymore
+    nhts_df = nhts_df.drop("CENSUS_D")
+
+    nhts_df = nhts_df.rename({
+        "HHSIZE": "occupants",
+        "HHFAMINC": "income",
+        "HHVEHCNT": "vehicles",
+        "URBRUR": "urban",
+        "TDWKND": "weekday",
+        "VEHCASEID": "vehicle_id",
+        "STRTTIME": "start_time",
+        "ENDTIME": "end_time",
+        "TRPMILES": "miles_driven",
+    })
+
+    return nhts_df
+
+
+def load_pums_data(pums_path: str, metadata_path: str) -> pl.DataFrame:
+    """
+    Load and preprocess the PUMS data for a specific state.
+
+    Args:
+        pums_path: Path to the PUMS data file
+        metadata_path: Path to metadata file for metro-PUMA mapping
+    """
+    if not Path(pums_path).exists():
+        msg = f"PUMS file not found: {pums_path}. Please run `just download-pums` to download the data."
+        raise FileNotFoundError(msg)
+
+    # Read CSV with "b" as null value and PUMA as string
+    pums_df = pl.read_csv(pums_path, null_values=["b"], schema_overrides={"PUMA": pl.Utf8})
+
+    pums_df = pums_df.rename({
+        "HINCP": "income",
+        "NP": "occupants",
+        "VEH": "vehicles",
+        "PUMA": "puma",
+        "WGTP": "hh_weight",
+    })
+
+    pums_df = pums_df.filter(pl.col("income") > 0)
+
+    # Convert vehicles to numeric (Int64)
+    pums_df = pums_df.with_columns([pl.col("vehicles").cast(pl.Int64)])
+
+    # If metadata_path is provided, join with metro-PUMA mapping
+    if metadata_path and Path(metadata_path).exists():
+        metro_puma_df = load_metro_puma_map(metadata_path)
+        pums_df = pums_df.join(metro_puma_df, on="puma", how="left")
+
+    return pums_df
+
+
+def load_weather_data(weather_path: str) -> pl.DataFrame:
+    """
+    Load hourly weather data (e.g., temperature) for a given location.
+
+    Args:
+        weather_path: Path to the weather data file (e.g., TMY3 CSV or EPW)
+
+    Returns:
+        DataFrame with at least columns ['datetime', 'temperature']
+    """
+    # if not Path(weather_path).exists():
+    #     msg = f"Weather file not found: {weather_path}"
+    #     raise FileNotFoundError(msg)
+
+    # TODO: Implement weather data loading
+    # This is a placeholder - replace with actual weather loading logic
+    return pl.DataFrame()  # Placeholder
+
+
+def load_metro_puma_map(metadata_path: str) -> pl.DataFrame:
+    """
+    Load the metro-puma mapping file. We need to assign the metro variable to the PUMS data based on a lookup of the puma code.
+    """
+    if not Path(metadata_path).exists():
+        msg = f"Metadata file not found: {metadata_path}"
+        raise FileNotFoundError(msg)
+
+    metro_lookup_df = pl.read_parquet(metadata_path, columns=["in.puma_metro_status", "in.puma"])
+
+    # Select and rename columns
+    metro_lookup_df = metro_lookup_df.select([
+        pl.col("in.puma_metro_status").alias("metro"),
+        pl.col("in.puma").alias("puma"),
+    ])
+
+    # Extract last 5 characters from PUMA and get distinct values
+    metro_lookup_df = metro_lookup_df.with_columns([pl.col("puma").str.slice(-5).alias("puma")]).unique()
+
+    return metro_lookup_df
+
+
+def load_all_input_data(ev_demand_config: Any) -> tuple[pl.DataFrame, pl.DataFrame, pl.DataFrame, pl.DataFrame]:
+    """
+    Load all input data for the EV demand calculator.
+
+    Returns:
+        Tuple of (metadata_df, nhts_df, pums_df, weather_df)
+    """
+    metadata_df = load_metadata(ev_demand_config.metadata_path)
+    nhts_df = load_nhts_data(ev_demand_config.nhts_path, ev_demand_config.state)
+    pums_df = load_pums_data(ev_demand_config.pums_path, ev_demand_config.metadata_path)
+    weather_df = load_weather_data(ev_demand_config.weather_path)
+
+    return metadata_df, nhts_df, pums_df, weather_df

buildstock_fetch/utils/resolve_bldgid_sets.py

@@ -0,0 +1,397 @@
+import json
+import os
+import re
+import tempfile
+import time
+import zipfile
+from pathlib import Path
+from typing import Any, TypedDict
+
+import boto3
+from botocore import UNSIGNED
+from botocore.config import Config
+
+
+class BuildStockRelease(TypedDict):
+    release_year: str
+    res_com: str
+    weather: str
+    release_number: str
+    upgrade_ids: list[str]
+    available_data: list[str]
+
+
+class CommonPrefix(TypedDict):
+    Prefix: str
+
+
+def _find_model_directory(s3_client: Any, bucket_name: str, prefix: str) -> str:
+    """
+    Find the building_energy_model directory path using breadth-first search.
+    """
+    paginator = s3_client.get_paginator("list_objects_v2")
+    # Queue contains tuples of (prefix, depth) where depth starts at 0
+    # Ensure prefix ends with / for proper directory listing
+    directories_to_search = [(prefix.rstrip("/") + "/", 0)]
+
+    while directories_to_search:
+        current_prefix, current_depth = directories_to_search.pop(0)  # Get next directory to search
+
+        # Stop if we've gone too deep
+        if current_depth >= 3:
+            continue
+
+        # List all directories at current level
+        pages = paginator.paginate(Bucket=bucket_name, Prefix=current_prefix, Delimiter="/")
+
+        for page in pages:
+            # First check directories at this level
+            if "CommonPrefixes" in page:
+                for prefix_obj in page["CommonPrefixes"]:
+                    dir_path = str(prefix_obj["Prefix"])  # Keep the trailing slash for next level search
+                    dir_name = dir_path.rstrip("/").split("/")[-1]
+
+                    # If we found the building_energy_model directory, return its path
+                    if "building_energy_model" in dir_name.lower():
+                        return dir_path.rstrip("/")  # Remove trailing slash from final result
+
+                    # Add this directory to be searched next, with increased depth
+                    directories_to_search.append((dir_path, current_depth + 1))
+
+    return ""
+
+
+def _get_upgrade_ids(s3_client: Any, bucket_name: str, model_path: str) -> list[str]:
+    """
+    Get the list of upgrade IDs from the building_energy_model directory.
+    Extracts the integer from upgrade=## format.
+    """
+    if not model_path:
+        return []
+
+    upgrade_ids = []
+    paginator = s3_client.get_paginator("list_objects_v2")
+    upgrade_pages = paginator.paginate(Bucket=bucket_name, Prefix=model_path + "/", Delimiter="/")
+
+    for page in upgrade_pages:
+        if "CommonPrefixes" in page:
+            for prefix_obj in page["CommonPrefixes"]:
+                upgrade_path = prefix_obj["Prefix"].rstrip("/")
+                upgrade_dir = upgrade_path.split("/")[-1]
+                # Extract the integer from upgrade=##
+                if upgrade_dir.startswith("upgrade="):
+                    upgrade_num = upgrade_dir.split("=")[1]
+                    upgrade_ids.append(upgrade_num)
+
+    return sorted(upgrade_ids, key=int)  # Sort numerically
+
+
+def _process_zip_file(
+    s3_client: Any, bucket_name: str, key: str, zip_files_found: int, unique_files: set[str]
+) -> tuple[int, set[str]]:
+    """Process a single zip file and return updated count of files found and available data types."""
+    available_data = set()
+    with tempfile.TemporaryDirectory() as temp_dir:
+        local_path = os.path.join(temp_dir, os.path.basename(key))
+        s3_client.download_file(bucket_name, key, local_path)
+        with zipfile.ZipFile(local_path, "r") as zip_ref:
+            for file_name in zip_ref.namelist():
+                unique_files.add(file_name)
+                # Check for XML files
+                if file_name.lower().endswith(".xml"):
+                    available_data.add("hpxml")
+                # Check for schedule CSV files
+                if file_name.lower().endswith(".csv") and "schedule" in file_name.lower():
+                    available_data.add("schedule")
+    return zip_files_found + 1, available_data
+
+
+def _check_directory_contents(
+    s3_client: Any, bucket_name: str, current_prefix: str, zip_files_found: int, unique_files: set[str]
+) -> tuple[int, bool, set[str]]:
+    """Check directory contents for zip files and process them."""
+    response = s3_client.list_objects_v2(Bucket=bucket_name, Prefix=current_prefix)
+    if "Contents" not in response:
+        return zip_files_found, False, set()
+
+    available_data = set()
+    for obj in response["Contents"]:
+        key = obj["Key"]
+        if key.endswith(".osm.gz"):
+            return zip_files_found, True, set()
+        if key.endswith(".zip") and zip_files_found < 5:
+            zip_files_found, zip_available_data = _process_zip_file(
+                s3_client, bucket_name, key, zip_files_found, unique_files
+            )
+            available_data.update(zip_available_data)
+            if zip_files_found == 5:
+                return zip_files_found, True, available_data
+
+    return zip_files_found, False, available_data
+
+
+def _find_and_process_model_file(s3_client: Any, bucket_name: str, prefix: str) -> set[str]:
+    """
+    Breadth-first search for the first 5 .zip files in building_energy_model directories.
+    Collects unique filenames from all zip files found.
+    Returns set of available data types found.
+    """
+    paginator = s3_client.get_paginator("list_objects_v2")
+    queue = [(prefix, 0)]  # (prefix, depth)
+    visited = set()
+    zip_files_found = 0
+    unique_files: set[str] = set()
+    available_data: set[str] = set()
+
+    while queue and zip_files_found < 5:
+        current_prefix, depth = queue.pop(0)
+        if current_prefix in visited:
+            continue
+
+        visited.add(current_prefix)
+
+        # Check current directory contents
+        zip_files_found, should_return, dir_available_data = _check_directory_contents(
+            s3_client, bucket_name, current_prefix, zip_files_found, unique_files
+        )
+        available_data.update(dir_available_data)
+        if should_return:
+            return available_data
+
+        # Check subdirectories
+        pages = paginator.paginate(Bucket=bucket_name, Prefix=current_prefix, Delimiter="/")
+        for page in pages:
+            if "CommonPrefixes" in page:
+                for prefix_obj in page["CommonPrefixes"]:
+                    dir_path = prefix_obj["Prefix"]
+                    dir_name = dir_path.rstrip("/").split("/")[-1]
+
+                    # Only queue directories that might contain building_energy_model
+                    if "building_energy_model" in dir_name.lower() or depth == 0:
+                        queue.append((dir_path, depth + 1))
+
+    return available_data
+
+
+def _process_directory_match(
+    s3_client: Any, bucket_name: str, current_prefix: str, expected: str, found_dirs: set[str]
+) -> None:
+    """Process a matched directory and update found_dirs accordingly."""
+    if expected == "building_energy_model":
+        available_data = _find_and_process_model_file(s3_client, bucket_name, current_prefix)
+        found_dirs.update(available_data - {"building_energy_model"})
+    elif expected == "timeseries_individual_buildings":
+        found_dirs.add("load_curve_15min")
+        found_dirs.add("load_curve_hourly")
+        found_dirs.add("load_curve_daily")
+        found_dirs.add("load_curve_monthly")
+        found_dirs.add("load_curve_annual")
+
+
+def _check_directory_matches(
+    s3_client: Any,
+    bucket_name: str,
+    current_prefix: str,
+    prefix: CommonPrefix,
+    expected_dirs: list[str],
+    found_dirs: set[str],
+) -> None:
+    """Check if a directory matches any expected directories and process it."""
+    dir_name = prefix["Prefix"].rstrip("/").split("/")[-1]
+    for expected in expected_dirs:
+        if expected in dir_name and expected not in found_dirs:
+            found_dirs.add(expected)
+            _process_directory_match(s3_client, bucket_name, current_prefix, expected, found_dirs)
+
+
+def _find_available_data(s3_client: Any, bucket_name: str, prefix: str) -> list[str]:
+    """
+    Find the available data directories (building_energy_model, metadata, timeseries_individual_buildings).
+    Returns a list of directories that exist, searching up to depth 3.
+    """
+    found_dirs: set[str] = set()
+    expected_dirs = ["building_energy_model", "metadata", "timeseries_individual_buildings"]
+    paginator = s3_client.get_paginator("list_objects_v2")
+
+    # Queue for BFS: (prefix, depth)
+    queue = [(prefix, 0)]
+    visited = set()
+
+    while queue and len(found_dirs) < len(expected_dirs):
+        current_prefix, depth = queue.pop(0)
+        if depth > 2 or current_prefix in visited:
+            continue
+
+        visited.add(current_prefix)
+        pages = paginator.paginate(Bucket=bucket_name, Prefix=current_prefix, Delimiter="/")
+
+        for page in pages:
+            if "CommonPrefixes" in page:
+                # First check current level for matches
+                for prefix_obj in page["CommonPrefixes"]:
+                    _check_directory_matches(
+                        s3_client, bucket_name, current_prefix, prefix_obj, expected_dirs, found_dirs
+                    )
+
+                # Then add subdirectories to queue for next level
+                for prefix_obj in page["CommonPrefixes"]:
+                    queue.append((str(prefix_obj["Prefix"]), depth + 1))
+
+    found_dirs.discard("building_energy_model")
+    found_dirs.discard("timeseries_individual_buildings")
+    return list(found_dirs)
+
+
+def _find_upgrade_ids(s3_client: Any, bucket_name: str, prefix: str) -> list[str]:
+    """
+    Find the unique building_energy_model directory and its upgrade IDs.
+    For 2021 releases, returns ['0'] as the only upgrade ID.
+
+    Args:
+        s3_client: Boto3 S3 client
+        bucket_name: Name of the S3 bucket
+        prefix: Path prefix to search under
+
+    Returns:
+        list[str]: List of upgrade IDs found in that directory
+    """
+    # For 2021 releases, return ['0'] as the only upgrade ID
+    if "/2021/" in prefix:
+        return ["0"]
+
+    model_path = _find_model_directory(s3_client, bucket_name, prefix)
+    upgrade_ids = _get_upgrade_ids(s3_client, bucket_name, model_path)
+    return upgrade_ids
+
+
+def _process_release(
+    s3_client: Any,
+    bucket_name: str,
+    release_path: str,
+    match: re.Match[str],
+    seen_combinations: set[tuple[str, str, str, str]],
+    releases: dict[str, BuildStockRelease],
+    available_data: list[str],
+) -> None:
+    """
+    Process a release directory and extract its metadata.
+    """
+    # Check if this is the 2024 pattern by looking at the pattern itself
+    if "2024/resstock_dataset_2024.1" in match.string:
+        release_year, res_com_type, _, release_number = match.groups()
+        weather = "tmy3"
+    else:
+        release_year, res_com_type, weather, release_number = match.groups()
+
+    combination = (release_year, f"{res_com_type}stock", weather, release_number)
+
+    if combination not in seen_combinations:
+        seen_combinations.add(combination)
+
+    # Find the building_energy_model directory and its upgrade IDs
+    upgrade_ids = _find_upgrade_ids(s3_client, bucket_name, release_path)
+
+    release_data: BuildStockRelease = {
+        "release_year": release_year,
+        "res_com": f"{res_com_type}stock",
+        "weather": weather,
+        "release_number": release_number,
+        "upgrade_ids": upgrade_ids,
+        "available_data": available_data,
+    }
+    # Create key following the pattern: {res/com}_{release_year}_{weather}_{release_number}
+    key = f"{res_com_type}_{release_year}_{weather}_{release_number}"
+    releases[key] = release_data
+
+
+def resolve_bldgid_sets(
+    bucket_name: str = "oedi-data-lake",
+    prefix: str = "nrel-pds-building-stock/end-use-load-profiles-for-us-building-stock",
+    output_file: str = "buildstock_releases.json",
+) -> dict[str, BuildStockRelease]:
+    """
+    Get URLs containing 'building_energy_models' from the NREL S3 bucket.
+    Parses the URL structure to extract available releases.
+
+    Args:
+        bucket_name (str): Name of the S3 bucket
+        prefix (str): Prefix path in the bucket to search
+        output_file (str): Path to output JSON file
+
+    Returns:
+        dict[str, BuildStockRelease]: Dictionary of releases with keys following pattern:
+            {res/com}_{release_year}_{weather}_{release_number}
+            Example: "res_2022_tmy3_1"
+            Each release includes the path to its building_energy_model directory
+            and the list of upgrade IDs available for that release.
+    """
+    # Initialize S3 client with unsigned requests (for public buckets)
+    s3_client = boto3.client("s3", config=Config(signature_version=UNSIGNED))
+
+    # Dictionary to store releases
+    releases: dict[str, BuildStockRelease] = {}
+    # Set to track unique combinations
+    seen_combinations: set[tuple[str, str, str, str]] = set()
+
+    # Regex pattern to extract components from full release path
+    pattern = r"(\d{4})/(res|com)stock_(\w+)_release_(\d+(?:\.\d+)?)"
+    # 2024 ResStock TMY3 release 1 has a different pattern from the rest
+    pattern_2024_resstock_tmy3_1 = r"(\d{4})/(res|com)stock_dataset_(\d{4})\.(\d+(?:\.\d+)?)"
+
+    # First, list all year directories
+    paginator = s3_client.get_paginator("list_objects_v2")
+    year_pages = paginator.paginate(Bucket=bucket_name, Prefix=prefix + "/", Delimiter="/")
+
+    for year_page in year_pages:
+        # Get common prefixes (directories) at this level
+        if "CommonPrefixes" not in year_page:
+            continue
+
+        for year_prefix in year_page["CommonPrefixes"]:
+            year_path = year_prefix["Prefix"]
+
+            # List contents of the year directory to find release directories
+            release_pages = paginator.paginate(Bucket=bucket_name, Prefix=year_path, Delimiter="/")
+
+            for release_page in release_pages:
+                if "CommonPrefixes" not in release_page:
+                    continue
+
+                for release_prefix in release_page["CommonPrefixes"]:
+                    release_path = release_prefix["Prefix"].rstrip("/")
+
+                    # Try to match the pattern against the full path
+                    relative_path = release_path.replace(prefix, "").lstrip("/")
+
+                    # Check for 2024 ResStock TMY3 release 1 pattern first
+                    match = re.match(pattern_2024_resstock_tmy3_1, relative_path)
+                    if match:
+                        available_data = _find_available_data(s3_client, bucket_name, release_path)
+                        _process_release(
+                            s3_client, bucket_name, release_path, match, seen_combinations, releases, available_data
+                        )
+                        continue
+
+                    # Then check for standard pattern
+                    match = re.match(pattern, relative_path)
+
+                    if match:
+                        available_data = _find_available_data(s3_client, bucket_name, release_path)
+                        _process_release(
+                            s3_client, bucket_name, release_path, match, seen_combinations, releases, available_data
+                        )
+
+    # Save to JSON file with consistent formatting
+    output_path = Path(__file__).parent / output_file
+    with open(output_path, "w", encoding="utf-8", newline="\n") as f:
+        json.dump(releases, f, indent=2, sort_keys=False, ensure_ascii=False)
+        f.write("\n")  # Ensure newline at end of file
+
+    return releases
+
+
+if __name__ == "__main__":
+    start_time = time.time()
+    releases = resolve_bldgid_sets()
+    elapsed_time = time.time() - start_time
+    print(f"\nFound {len(releases)} unique releases in {elapsed_time:.2f} seconds")