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

buildstock_fetch/main.py

@@ -1,5 +1,6 @@
 import concurrent.futures
 import json
+import tempfile
 import zipfile
 from dataclasses import asdict, dataclass
 from importlib.resources import files
@@ -58,10 +59,30 @@ class NoAnnualLoadCurveError(ValueError):
     pass
 
 
+class NoAggregateLoadCurveError(ValueError):
+    """Raised when no monthly load curve is available for a given release."""
+
+    pass
+
+
+class UnknownAggregationFunctionError(ValueError):
+    """Raised when an unknown aggregation function is provided."""
+
+    pass
+
+
 METADATA_DIR = Path(
     str(files("buildstock_fetch").joinpath("data").joinpath("building_data").joinpath("combined_metadata.parquet"))
 )
 RELEASE_JSON_FILE = Path(str(files("buildstock_fetch").joinpath("data").joinpath("buildstock_releases.json")))
+LOAD_CURVE_COLUMN_AGGREGATION = Path(
+    str(
+        files("buildstock_fetch")
+        .joinpath("data")
+        .joinpath("load_curve_column_map")
+        .joinpath("2024_resstock_load_curve_columns.csv")
+    )
+)
 
 
 @dataclass
@@ -234,6 +255,10 @@ class BuildingID:
         else:
             return ""
 
+    def get_aggregate_load_curve_url(self) -> str:
+        """Generate the S3 download URL for this building. The url is the same as the 15-minute load curve url."""
+        return self.get_15min_load_curve_url()
+
     def get_annual_load_curve_url(self) -> str:
         """Generate the S3 download URL for this building."""
         if not self._validate_requested_file_type_availability("load_curve_annual"):
@@ -497,6 +522,146 @@ def _download_with_progress(url: str, output_file: Path, progress: Progress, tas
     return downloaded_size
 
 
+def _get_time_step_grouping_key(aggregate_time_step: str) -> tuple[str, str]:
+    """Get the grouping key and format string for a given time step.
+
+    Args:
+        aggregate_time_step: The time step to aggregate to ("monthly", "hourly", "daily")
+
+    Returns:
+        A tuple of (grouping_key_name, format_string)
+    """
+    time_step_configs = {
+        "monthly": ("year_month", "%Y-%m"),
+        "hourly": ("year_month_day_hour", "%Y-%m-%d-%H"),
+        "daily": ("year_month_day", "%Y-%m-%d"),
+    }
+
+    if aggregate_time_step not in time_step_configs:
+        msg = f"Unknown aggregate time step: {aggregate_time_step}"
+        raise ValueError(msg)
+
+    return time_step_configs[aggregate_time_step]
+
+
+def _create_aggregation_expressions(load_curve: pl.DataFrame, column_aggregations: dict[str, str]) -> list[pl.Expr]:
+    """Create aggregation expressions for each column based on the aggregation rules.
+
+    Args:
+        load_curve: The DataFrame to create expressions for
+        column_aggregations: Dictionary mapping column names to aggregation functions
+
+    Returns:
+        List of Polars expressions for aggregation
+    """
+    agg_exprs = []
+
+    for col in load_curve.columns:
+        if col in ["timestamp", "year_month", "year_month_day_hour", "year_month_day"]:
+            continue
+
+        if col in column_aggregations:
+            agg_func = column_aggregations[col]
+            if agg_func == "sum":
+                agg_exprs.append(pl.col(col).sum().alias(col))
+            elif agg_func == "mean":
+                agg_exprs.append(pl.col(col).mean().alias(col))
+            elif agg_func == "first":
+                agg_exprs.append(pl.col(col).first().alias(col))
+            else:
+                raise UnknownAggregationFunctionError()
+        else:
+            raise UnknownAggregationFunctionError()
+
+    # Add timestamp aggregation (take the first timestamp of each group)
+    agg_exprs.append(pl.col("timestamp").first().alias("timestamp"))
+
+    return agg_exprs
+
+
+def _aggregate_load_curve_aggregate(load_curve: pl.DataFrame, aggregate_time_step: str) -> pl.DataFrame:
+    """Aggregate the 15-minute load curve to specified time step based on aggregation rules."""
+    # Read the aggregation rules from CSV
+    aggregation_rules = pl.read_csv(LOAD_CURVE_COLUMN_AGGREGATION)
+
+    # Create a dictionary mapping column names to their aggregation functions
+    column_aggregations = dict(zip(aggregation_rules["name"], aggregation_rules["Aggregate_function"]))
+
+    # Ensure timestamp column exists and convert to datetime if needed
+    if "timestamp" not in load_curve.columns:
+        msg = "DataFrame must contain a 'timestamp' column"
+        raise ValueError(msg)
+
+    # Convert timestamp to datetime if it's not already
+    load_curve = load_curve.with_columns(pl.col("timestamp").cast(pl.Datetime))
+
+    # Get the grouping key configuration
+    grouping_key, format_string = _get_time_step_grouping_key(aggregate_time_step)
+
+    # Create grouping key
+    load_curve = load_curve.with_columns(pl.col("timestamp").dt.strftime(format_string).alias(grouping_key))
+
+    # Create aggregation expressions
+    agg_exprs = _create_aggregation_expressions(load_curve, column_aggregations)
+
+    # Perform the aggregation
+    aggregate_data = load_curve.group_by(grouping_key).agg(agg_exprs)
+
+    # Sort by timestamp and drop the grouping column
+    aggregate_data = aggregate_data.sort("timestamp").drop(grouping_key)
+
+    return aggregate_data
+
+
+def _download_and_process_aggregate(
+    url: str, output_file: Path, progress: Progress, task_id: TaskID, aggregate_time_step: str
+) -> int:
+    """Download aggregate time step load curve to temporary file, process with Polars, and save result."""
+    # Get file size first for progress tracking
+    response = requests.head(url, timeout=30)
+    response.raise_for_status()
+    total_size = int(response.headers.get("content-length", 0))
+    progress.update(task_id, total=total_size)
+
+    # Download to temporary file
+    with tempfile.NamedTemporaryFile(delete=False, suffix=".parquet") as temp_file:
+        temp_path = Path(temp_file.name)
+
+        try:
+            # Create session with retry logic
+            session = requests.Session()
+            retry_strategy = requests.adapters.HTTPAdapter(max_retries=15)
+            session.mount("http://", retry_strategy)
+            session.mount("https://", retry_strategy)
+
+            # Download with streaming to temp file
+            response = session.get(url, stream=True, timeout=60)
+            response.raise_for_status()
+
+            downloaded_size = 0
+            with open(temp_path, "wb") as file:
+                for chunk in response.iter_content(chunk_size=8192):
+                    if chunk:
+                        file.write(chunk)
+                        downloaded_size += len(chunk)
+                        if total_size > 0:
+                            progress.update(task_id, completed=downloaded_size)
+
+            # Process with Polars
+            load_curve_15min = pl.read_parquet(temp_path)
+            load_curve_aggregate = _aggregate_load_curve_aggregate(load_curve_15min, aggregate_time_step)
+
+            # Save processed file to final destination
+            load_curve_aggregate.write_parquet(output_file)
+
+            return downloaded_size
+
+        finally:
+            # Clean up temporary file
+            if temp_path.exists():
+                temp_path.unlink()
+
+
 def download_bldg_data(
     bldg_id: BuildingID,
     file_type: RequestedFileTypes,
@@ -563,7 +728,7 @@ def download_bldg_data(
                         / bldg_id.get_release_name()
                         / "hpxml"
                         / bldg_id.state
-                        / f"up{str(int(bldg_id.upgrade_id)).zfill(2)}"
+                        / f"upgrade={str(int(bldg_id.upgrade_id)).zfill(2)}"
                         / new_name
                     )
                     new_path.parent.mkdir(parents=True, exist_ok=True)
@@ -584,7 +749,7 @@ def download_bldg_data(
                         / bldg_id.get_release_name()
                         / "schedule"
                         / bldg_id.state
-                        / f"up{str(int(bldg_id.upgrade_id)).zfill(2)}"
+                        / f"upgrade={str(int(bldg_id.upgrade_id)).zfill(2)}"
                         / new_name
                     )
                     new_path.parent.mkdir(parents=True, exist_ok=True)
@@ -616,8 +781,8 @@ def download_metadata(bldg_id: BuildingID, output_dir: Path) -> Path:
         output_dir
         / bldg_id.get_release_name()
         / "metadata"
-        / bldg_id.state
-        / f"up{str(int(bldg_id.upgrade_id)).zfill(2)}"
+        / f"state={bldg_id.state}"
+        / f"upgrade={str(int(bldg_id.upgrade_id)).zfill(2)}"
         / "metadata.parquet"
     )
     output_file.parent.mkdir(parents=True, exist_ok=True)
@@ -643,9 +808,9 @@ def download_15min_load_curve(bldg_id: BuildingID, output_dir: Path) -> Path:
         output_dir
         / bldg_id.get_release_name()
         / "load_curve_15min"
-        / bldg_id.state
-        / f"up{str(int(bldg_id.upgrade_id)).zfill(2)}"
-        / f"bldg{str(bldg_id.bldg_id).zfill(7)}-up{str(int(bldg_id.upgrade_id)).zfill(2)}_load_curve_15min.parquet"
+        / f"state={bldg_id.state}"
+        / f"upgrade={str(int(bldg_id.upgrade_id)).zfill(2)}"
+        / f"bldg{str(bldg_id.bldg_id).zfill(7)}_load_curve_15min.parquet"
     )
     output_file.parent.mkdir(parents=True, exist_ok=True)
     output_file.write_bytes(response.content)
@@ -675,9 +840,9 @@ def download_15min_load_curve_with_progress(
         output_dir
         / bldg_id.get_release_name()
         / "load_curve_15min"
-        / bldg_id.state
-        / f"up{str(int(bldg_id.upgrade_id)).zfill(2)}"
-        / f"bldg{str(bldg_id.bldg_id).zfill(7)}-up{str(int(bldg_id.upgrade_id)).zfill(2)}_load_curve_15min.parquet"
+        / f"state={bldg_id.state}"
+        / f"upgrade={str(int(bldg_id.upgrade_id)).zfill(2)}"
+        / f"bldg{str(bldg_id.bldg_id).zfill(7)}_load_curve_15min.parquet"
     )
     output_file.parent.mkdir(parents=True, exist_ok=True)
 
@@ -692,6 +857,66 @@ def download_15min_load_curve_with_progress(
     return output_file
 
 
+def download_aggregate_time_step_load_curve_with_progress(
+    bldg_id: BuildingID,
+    output_dir: Path,
+    progress: Optional[Progress],
+    task_id: Optional[TaskID],
+    aggregate_time_step: str,
+) -> Path:
+    """Download the aggregate time step load profile timeseries for a given building with progress tracking."""
+
+    download_url = bldg_id.get_aggregate_load_curve_url()
+    if download_url == "":
+        message = f"Aggregate load profile timeseries is not available for {bldg_id.get_release_name()}"
+        raise NoAggregateLoadCurveError(message)
+
+    if aggregate_time_step == "monthly":
+        load_curve_dir = "load_curve_monthly"
+    elif aggregate_time_step == "hourly":
+        load_curve_dir = "load_curve_hourly"
+    elif aggregate_time_step == "daily":
+        load_curve_dir = "load_curve_daily"
+    else:
+        message = f"Unknown aggregate time step: {aggregate_time_step}"
+        raise ValueError(message)
+
+    output_file = (
+        output_dir
+        / bldg_id.get_release_name()
+        / load_curve_dir
+        / f"state={bldg_id.state}"
+        / f"upgrade={str(int(bldg_id.upgrade_id)).zfill(2)}"
+        / f"bldg{str(bldg_id.bldg_id).zfill(7)}_load_curve_{aggregate_time_step}.parquet"
+    )
+
+    output_file.parent.mkdir(parents=True, exist_ok=True)
+
+    # Download with progress tracking if progress object is provided
+    if progress and task_id is not None:
+        _download_and_process_aggregate(download_url, output_file, progress, task_id, aggregate_time_step)
+    else:
+        # For non-progress downloads, still use temp file approach for consistency
+        with tempfile.NamedTemporaryFile(delete=False, suffix=".parquet") as temp_file:
+            temp_path = Path(temp_file.name)
+            try:
+                response = requests.get(download_url, timeout=30)
+                response.raise_for_status()
+                temp_path.write_bytes(response.content)
+
+                # Process with Polars
+                load_curve_15min = pl.read_parquet(temp_path)
+                load_curve_aggregate = _aggregate_load_curve_aggregate(load_curve_15min, aggregate_time_step)
+
+                # Save processed file to final destination
+                load_curve_aggregate.write_parquet(output_file)
+            finally:
+                if temp_path.exists():
+                    temp_path.unlink()
+
+    return output_file
+
+
 def _parse_requested_file_type(file_type: tuple[str, ...]) -> RequestedFileTypes:
     """Parse the file type string into a RequestedFileTypes object."""
     file_type_obj = RequestedFileTypes()
@@ -764,8 +989,8 @@ def _download_metadata_with_progress(bldg: BuildingID, output_dir: Path, progres
         output_dir
         / bldg.get_release_name()
         / "metadata"
-        / bldg.state
-        / f"up{str(int(bldg.upgrade_id)).zfill(2)}"
+        / f"state={bldg.state}"
+        / f"upgrade={str(int(bldg.upgrade_id)).zfill(2)}"
         / "metadata.parquet"
     )
     output_file.parent.mkdir(parents=True, exist_ok=True)
@@ -851,8 +1076,9 @@ def _download_15min_load_curves_parallel(
                     output_dir
                     / bldg_id.get_release_name()
                     / "load_curve_15min"
-                    / bldg_id.state
-                    / f"bldg{str(bldg_id.bldg_id).zfill(7)}-up{str(int(bldg_id.upgrade_id)).zfill(2)}_load_curve_15min.parquet"
+                    / f"state={bldg_id.state}"
+                    / f"upgrade={str(int(bldg_id.upgrade_id)).zfill(2)}"
+                    / f"bldg{str(bldg_id.bldg_id).zfill(7)}_load_curve_15min.parquet"
                 )
                 failed_downloads.append(str(output_file))
                 console.print(f"[red]15 min load curve not available for {bldg_id.get_release_name()}[/red]")
@@ -862,13 +1088,162 @@ def _download_15min_load_curves_parallel(
                     output_dir
                     / bldg_id.get_release_name()
                     / "load_curve_15min"
-                    / bldg_id.state
-                    / f"bldg{str(bldg_id.bldg_id).zfill(7)}-up{str(int(bldg_id.upgrade_id)).zfill(2)}_load_curve_15min.parquet"
+                    / f"state={bldg_id.state}"
+                    / f"upgrade={str(int(bldg_id.upgrade_id)).zfill(2)}"
+                    / f"bldg{str(bldg_id.bldg_id).zfill(7)}_load_curve_15min.parquet"
                 )
                 failed_downloads.append(str(output_file))
                 console.print(f"[red]Download failed for 15 min load curve {bldg_id.bldg_id}: {e}[/red]")
 
 
+def _create_batch_progress_tasks(
+    bldg_ids: list[BuildingID], aggregate_time_step: str, progress: Progress, console: Console
+) -> dict[int, TaskID]:
+    """Create progress tasks for batch processing."""
+    batch_size = 100
+    num_batches = (len(bldg_ids) + batch_size - 1) // batch_size
+    console.print(f"[blue]Using batch processing: {len(bldg_ids)} buildings split into {num_batches} batches[/blue]")
+
+    load_curve_tasks = {}
+    for i in range(num_batches):
+        # Calculate how many buildings are in this batch
+        start_idx = i * batch_size
+        end_idx = min(start_idx + batch_size, len(bldg_ids))
+        batch_count = end_idx - start_idx
+
+        console.print(f"[blue]Batch {i + 1}/{num_batches}: {batch_count} buildings[/blue]")
+
+        task_id = progress.add_task(
+            f"[magenta]Batch {i + 1}/{num_batches} ({aggregate_time_step})",
+            total=batch_count,  # Set total to the number of buildings in this batch
+        )
+        load_curve_tasks[i] = task_id
+
+    return load_curve_tasks
+
+
+def _create_individual_progress_tasks(bldg_ids: list[BuildingID], progress: Progress) -> dict[int, TaskID]:
+    """Create progress tasks for individual building processing."""
+    load_curve_tasks = {}
+    for i, bldg_id in enumerate(bldg_ids):
+        task_id = progress.add_task(
+            f"[magenta]Load curve {bldg_id.bldg_id} (upgrade {bldg_id.upgrade_id})",
+            total=0,  # Will be updated when we get the file size
+        )
+        load_curve_tasks[i] = task_id
+    return load_curve_tasks
+
+
+def _download_aggregate_with_batch_progress(
+    bldg_id: BuildingID, output_dir: Path, task_id: TaskID, aggregate_time_step: str, progress: Progress
+) -> Path:
+    """Download with batch progress tracking."""
+    # Download the file without individual progress tracking
+    result = download_aggregate_time_step_load_curve_with_progress(bldg_id, output_dir, None, None, aggregate_time_step)
+    # Update batch progress by 1
+    progress.update(task_id, advance=1)
+    return result
+
+
+def _process_download_future(
+    future: concurrent.futures.Future,
+    bldg_id: BuildingID,
+    output_dir: Path,
+    aggregate_time_step: str,
+    downloaded_paths: list[Path],
+    failed_downloads: list[str],
+    console: Console,
+) -> None:
+    """Process a completed download future."""
+    try:
+        output_file = future.result()
+        downloaded_paths.append(output_file)
+    except NoAggregateLoadCurveError:
+        output_file = (
+            output_dir
+            / bldg_id.get_release_name()
+            / "load_curve_monthly"
+            / f"state={bldg_id.state}"
+            / f"bldg{str(bldg_id.bldg_id).zfill(7)}_load_curve_monthly.parquet"
+        )
+        failed_downloads.append(str(output_file))
+        console.print(f"[red]Monthly load curve not available for {bldg_id.get_release_name()}[/red]")
+        raise
+    except Exception as e:
+        output_file = (
+            output_dir
+            / bldg_id.get_release_name()
+            / "load_curve_monthly"
+            / f"state={bldg_id.state}"
+            / f"bldg{str(bldg_id.bldg_id).zfill(7)}_load_curve_monthly.parquet"
+        )
+        failed_downloads.append(str(output_file))
+        console.print(f"[red]Download failed for monthly load curve {bldg_id.bldg_id}: {e}[/red]")
+
+
+def _download_aggregate_load_curves_parallel(
+    bldg_ids: list[BuildingID],
+    output_dir: Path,
+    aggregate_time_step: str,
+    max_workers: int,
+    progress: Progress,
+    downloaded_paths: list[Path],
+    failed_downloads: list[str],
+    console: Console,
+) -> None:
+    """Download monthly load curves in parallel with progress tracking."""
+
+    # Create progress tasks based on dataset size
+    if len(bldg_ids) > 500:
+        load_curve_tasks = _create_batch_progress_tasks(bldg_ids, aggregate_time_step, progress, console)
+    else:
+        load_curve_tasks = _create_individual_progress_tasks(bldg_ids, progress)
+
+    # Create download functions
+    def download_aggregate_with_task_id(
+        bldg_id: BuildingID, output_dir: Path, task_id: TaskID, aggregate_time_step: str
+    ) -> Path:
+        return download_aggregate_time_step_load_curve_with_progress(
+            bldg_id, output_dir, progress, task_id, aggregate_time_step
+        )
+
+    with concurrent.futures.ThreadPoolExecutor(max_workers=max_workers) as executor:
+        if len(bldg_ids) > 500:
+            # Process in batches for large datasets
+            batch_size = 100
+            future_to_bldg = {}
+
+            for batch_idx in range(0, len(bldg_ids), batch_size):
+                batch = bldg_ids[batch_idx : batch_idx + batch_size]
+                task_id = load_curve_tasks[batch_idx // batch_size]
+
+                for bldg_id in batch:
+                    future = executor.submit(
+                        _download_aggregate_with_batch_progress,
+                        bldg_id,
+                        output_dir,
+                        task_id,
+                        aggregate_time_step,
+                        progress,
+                    )
+                    future_to_bldg[future] = bldg_id
+        else:
+            # Original behavior for smaller datasets
+            future_to_bldg = {
+                executor.submit(
+                    download_aggregate_with_task_id, bldg_id, output_dir, load_curve_tasks[i], aggregate_time_step
+                ): bldg_id
+                for i, bldg_id in enumerate(bldg_ids)
+            }
+
+        # Process completed futures
+        for future in concurrent.futures.as_completed(future_to_bldg):
+            bldg_id = future_to_bldg[future]
+            _process_download_future(
+                future, bldg_id, output_dir, aggregate_time_step, downloaded_paths, failed_downloads, console
+            )
+
+
 def _download_metadata_single(
     bldg_ids: list[BuildingID],
     output_dir: Path,
@@ -912,8 +1287,8 @@ def download_annual_load_curve_with_progress(
         output_dir
         / bldg_id.get_release_name()
         / "load_curve_annual"
-        / bldg_id.state
-        / f"up{str(int(bldg_id.upgrade_id)).zfill(2)}"
+        / f"state={bldg_id.state}"
+        / f"upgrade={str(int(bldg_id.upgrade_id)).zfill(2)}"
         / output_filename
     )
 
@@ -974,8 +1349,9 @@ def _download_annual_load_curves_parallel(
                     output_dir
                     / bldg_id.get_release_name()
                     / "load_curve_annual"
-                    / bldg_id.state
-                    / f"bldg{str(bldg_id.bldg_id).zfill(7)}-up{str(int(bldg_id.upgrade_id)).zfill(2)}_load_curve_annual.parquet"
+                    / f"state={bldg_id.state}"
+                    / f"upgrade={str(int(bldg_id.upgrade_id)).zfill(2)}"
+                    / f"bldg{str(bldg_id.bldg_id).zfill(7)}_load_curve_annual.parquet"
                 )
                 failed_downloads.append(str(output_file))
                 console.print(f"[red]Annual load curve not available for {bldg_id.get_release_name()}[/red]")
@@ -985,8 +1361,9 @@ def _download_annual_load_curves_parallel(
                     output_dir
                     / bldg_id.get_release_name()
                     / "load_curve_annual"
-                    / bldg_id.state
-                    / f"bldg{str(bldg_id.bldg_id).zfill(7)}-up{str(int(bldg_id.upgrade_id)).zfill(2)}_load_curve_annual.parquet"
+                    / f"state={bldg_id.state}"
+                    / f"upgrade={str(int(bldg_id.upgrade_id)).zfill(2)}"
+                    / f"bldg{str(bldg_id.bldg_id).zfill(7)}_load_curve_annual.parquet"
                 )
                 failed_downloads.append(str(output_file))
                 console.print(f"[red]Download failed for annual load curve {bldg_id.bldg_id}: {e}[/red]")
@@ -1022,11 +1399,13 @@ def fetch_bldg_data(
     failed_downloads: list[str] = []
 
     # Calculate total files to download
-    total_files = len(bldg_ids)
+    total_files = 0
     if file_type_obj.metadata:
         total_files += 1  # Add metadata file
     if file_type_obj.load_curve_15min:
         total_files += len(bldg_ids)  # Add 15-minute load curve files
+    if file_type_obj.load_curve_monthly:
+        total_files += len(bldg_ids)  # Add 15-minute load curve files
     if file_type_obj.load_curve_annual:
         total_files += len(bldg_ids)  # Add annual load curve files
 
@@ -1062,6 +1441,19 @@ def fetch_bldg_data(
                 bldg_ids, output_dir, max_workers, progress, downloaded_paths, failed_downloads, console
             )
 
+        if file_type_obj.load_curve_monthly:
+            aggregate_time_step = "monthly"
+            _download_aggregate_load_curves_parallel(
+                bldg_ids,
+                output_dir,
+                aggregate_time_step,
+                max_workers,
+                progress,
+                downloaded_paths,
+                failed_downloads,
+                console,
+            )
+
         # Get annual load curve if requested.
         if file_type_obj.load_curve_annual:
             _download_annual_load_curves_parallel(
@@ -1074,25 +1466,4 @@ def fetch_bldg_data(
 
 
 if __name__ == "__main__":  # pragma: no cover
-    bldg_ids = [
-        BuildingID(
-            bldg_id=5634,
-            release_year="2024",
-            res_com="comstock",
-            weather="amy2018",
-            upgrade_id="1",
-            release_number="2",
-            state="AL",
-        ),
-        BuildingID(
-            bldg_id=78270,
-            release_year="2024",
-            res_com="comstock",
-            weather="amy2018",
-            upgrade_id="1",
-            release_number="2",
-            state="DE",
-        ),
-    ]
-    for bldg_id in bldg_ids:
-        print(bldg_id._get_county_name())
+    print(fetch_bldg_ids("comstock", "2021", "tmy3", "1", "MA", "0")[:3])

buildstock_fetch/main_cli.py

@@ -1,6 +1,5 @@
 import json
 import pprint
-import random
 from collections.abc import Mapping
 from importlib.resources import files
 from pathlib import Path
@@ -380,6 +379,7 @@ def _run_interactive_mode() -> dict[str, Union[str, list[str]]]:
             validate=_validate_output_directory,
         ).ask()
     )
+
     output_directory_path = Path(output_directory_str)
     output_directory_path.mkdir(parents=True, exist_ok=True)
     return {
@@ -433,7 +433,7 @@ def _print_data_processing_info(inputs: Mapping[str, Union[str, list[str]]]) ->
 
 def _check_unavailable_file_types(inputs: Mapping[str, Union[str, list[str]]]) -> None:
     """Check and print warning for unavailable file types."""
-    unavailable_file_types = ["load_curve_hourly", "load_curve_daily", "load_curve_monthly"]
+    unavailable_file_types = ["load_curve_hourly", "load_curve_daily"]
     selected_file_types = inputs["file_type"].split() if isinstance(inputs["file_type"], str) else inputs["file_type"]
     selected_unavailable = [ft for ft in selected_file_types if ft in unavailable_file_types]
     if selected_unavailable:
@@ -512,8 +512,8 @@ def _get_user_download_choice(bldg_ids: list) -> list:
                 console.print(f"[yellow]No files will be downloaded for State {state}, Upgrade {upgrade_id}.[/yellow]")
                 continue
 
-            # Randomly select the specified number of building IDs for this state-upgrade_id pair
-            selected_for_state_upgrade = random.sample(bldg_list, sample_size)
+            # Select the first N building IDs for this state-upgrade_id pair
+            selected_for_state_upgrade = bldg_list[:sample_size]
             selected_bldg_ids.extend(selected_for_state_upgrade)
             console.print(f"[green]Selected {sample_size} buildings for State {state}, Upgrade {upgrade_id}.[/green]")
 

{buildstock_fetch-1.0.4.dist-info → buildstock_fetch-1.1.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: buildstock-fetch
-Version: 1.0.4
+Version: 1.1.0
 Summary: This library simplifies downloading building characteristics and load curve data from NREL's ResStock and ComStock projects.
 Author-email: Switchbox <hello@switch.box>
 Project-URL: Homepage, https://switchbox-data.github.io/buildstock-fetch/
@@ -44,6 +44,7 @@ Requires-Dist: botocore>=1.33.0; extra == "dev-utils"
 Requires-Dist: pyarrow>=14.0.1; extra == "dev-utils"
 Requires-Dist: numpy>=1.26.4; extra == "dev-utils"
 Requires-Dist: scikit-learn>=1.6.1; extra == "dev-utils"
+Requires-Dist: xmltodict>=0.14.2; extra == "dev-utils"
 Provides-Extra: dev
 Requires-Dist: buildstock-fetch[dev-utils,docs,lint,test]; extra == "dev"
 Requires-Dist: tox-uv>=1.11.3; extra == "dev"
@@ -59,7 +60,8 @@ Dynamic: license-file
 This library simplifies downloading building characteristics and load curve data from NREL's ResStock and ComStock projects.
 
 - **Github repository**: <https://github.com/switchbox-data/buildstock-fetch/>
-- **Documentation** <https://switchbox-data.github.io/buildstock-fetch/>
+- **Documentation**: <https://switchbox-data.github.io/buildstock-fetch/>
+- **PyPI page***: <https://pypi.org/project/buildstock-fetch/>
 
 ## Installing the library