buildstock-fetch 1.0.2__py3-none-any.whl → 1.0.4__py3-none-any.whl

buildstock_fetch/utils/ev_utils.py

@@ -1,270 +0,0 @@
-"""
-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

@@ -1,397 +0,0 @@
-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")