Merge branch 'master' of https://github.com/architecture-building-systems/CityEnergyAnalyst

Author: reyery

cea/config.py

@@ -1279,7 +1279,7 @@ def _choices(self):
             return list(codes)
         except FileNotFoundError as e:
             # FIXME: This might cause default config to fail since the file does not exist, maybe should be a warning?
-            raise FileNotFoundError(f'Could not find source file at {location}') from e
+            raise FileNotFoundError(f'Could not find source file at {location} to generate choices for {self.name}') from e
         except Exception as e:
             raise ValueError(f'There was an error generating choices for {self.name} from {location}') from e
 

cea/default.config

@@ -750,7 +750,7 @@ results-summary-and-analytics.help = True if generating a summary and advanced a
 folder-name-to-save-exported-results =
 folder-name-to-save-exported-results.type = StringParameter
 folder-name-to-save-exported-results.nullable = true
-folder-name-to-save-exported-results.help = Name the folder to store the exported .csv files, which to be found under Path - current_Scenario/export/results/summary_name_done_time. When left blank, the default path is to set as - current_Scenario/export/results/hours_period_range_done_time.
+folder-name-to-save-exported-results.help = Name the folder to store the exported .csv files, which to be found under Path - current_Scenario/export/results/summary_name_current_time
 
 buildings =
 buildings.type = BuildingsParameter

cea/import_export/result_summary.py

@@ -8,7 +8,7 @@
 import numpy as np
 import cea.config
 import time
-from datetime import datetime
+from datetime import datetime, UTC
 import cea.inputlocator
 import geopandas as gpd
 
@@ -2406,8 +2406,9 @@ def process_building_summary(config, locator,
 
     # Step 2: Get User-Defined Folder Name & Create Folder if it Doesn't Exist
     if not plot:
-        folder_name = config.result_summary.folder_name_to_save_exported_results
-        summary_folder = locator.get_export_results_summary_folder(hour_start, hour_end, folder_name)
+        folder_name = config.result_summary.folder_name_to_save_exported_results or "summary"
+        summary_folder = locator.get_export_results_summary_folder(f"{folder_name}-{datetime.now(UTC).strftime('%Y%m%d-%H%M%S')}")
+        print(f"Results will be saved to: {summary_folder}")
     else:
         summary_folder = locator.get_export_plots_folder()
     os.makedirs(summary_folder, exist_ok=True)

cea/inputlocator.py

@@ -152,23 +152,9 @@ def get_export_plots_selected_building_file(self):
         """scenario/export/plots/{plot_cea_feature}/selected_buildings.csv"""
         return os.path.join(self.get_export_plots_folder(), 'selected_buildings.csv')
 
-    def get_export_results_summary_folder(self, hour_start, hour_end, folder_name):
-        if folder_name is None or folder_name.strip() == "":
-            """scenario/export/results/hours_{hour_start}_{hour_end}_done_{current_time}"""
-            path = os.path.join(self.get_export_results_folder(), f'unnamed_hours_{hour_start}_{hour_end}')
-        else:
-            """scenario/export/results/{folder_name}_done_{current_time}"""
-            path = os.path.join(self.get_export_results_folder(), f'{folder_name}_hours_{hour_start}_{hour_end}')
-
-        # new path ending with _1, _2, _3 if the user-defined path exists
-        base_path = path
-        counter = 1
-
-        while os.path.exists(path):
-            path = f"{base_path}_{counter}"
-            counter += 1
-
-        return path
+    def get_export_results_summary_folder(self, folder_name):
+        """scenario/export/results/{folder_name}"""
+        return os.path.join(self.get_export_results_folder(), folder_name)
 
     def get_export_results_summary_selected_building_file(self, summary_folder):
         """scenario/export/results/{folder_name}/selected_buildings.csv"""

cea/interfaces/dashboard/api/contents.py

@@ -9,11 +9,13 @@
 from typing import Optional, List
 
 from fastapi import APIRouter, HTTPException, status, Form, UploadFile
+from fastapi.concurrency import run_in_threadpool
 from pydantic import BaseModel
 from starlette.responses import StreamingResponse
 from typing_extensions import Annotated, Literal
 
 import cea.config
+import cea.inputlocator
 from cea.datamanagement.format_helper.cea4_migrate import migrate_cea3_to_cea4
 from cea.datamanagement.format_helper.cea4_migrate_db import migrate_cea3_to_cea4_db
 from cea.datamanagement.format_helper.cea4_verify import cea4_verify
@@ -397,6 +399,23 @@ class DownloadScenario(BaseModel):
     project: str
     scenarios: List[str]
     input_files: bool
+    output_files: Literal["summary", "detailed"]
+
+
+def run_summary(project: str, scenario_name: str):
+    """Run the summary function to ensure all summary files are generated"""
+    config = cea.config.Configuration(cea.config.DEFAULT_CONFIG)
+    config.project = project
+    config.scenario_name = scenario_name
+
+    config.result_summary.aggregate_by_building = True
+
+    try:
+        from cea.import_export.result_summary import main as result_summary_main
+        result_summary_main(config)
+    except Exception as e:
+        logger.error(f"Error generating summary for {scenario_name}: {str(e)}")
+        raise e
 
 
 @router.post("/scenario/download")
@@ -414,33 +433,75 @@ async def download_scenario(form: DownloadScenario, project_root: CEAProjectRoot
 
     project = form.project.strip()
     scenarios = form.scenarios
-    input_files_only = form.input_files
+    input_files = form.input_files
+    output_files_level = form.output_files
 
     filename = f"{project}_scenarios.zip" if len(scenarios) > 1 else f"{project}_{scenarios[0]}.zip"
 
     temp_file_path = None
     try:
         with tempfile.NamedTemporaryFile(delete=False) as temp_file:
             temp_file_path = temp_file.name
-            with zipfile.ZipFile(temp_file, 'w', zipfile.ZIP_DEFLATED) as zip_file:
-                base_path = Path(project_root) / project
+
+            # Use compresslevel=1 for faster zipping, at the cost of compression ratio
+            with zipfile.ZipFile(temp_file, 'w', zipfile.ZIP_DEFLATED, compresslevel=1) as zip_file:
+                base_path = Path(secure_path(Path(project_root, project).resolve()))
 
+                # Collect all files first for batch processing
+                files_to_zip = []
                 for scenario in scenarios:
-                    scenario_path = base_path / scenario
+                    # sanitize scenario for fs ops and zip arcnames
+                    scenario_name = Path(scenario).name
+                    scenario_path = Path(secure_path((base_path / scenario_name).resolve()))
+
                     if not scenario_path.exists():
                         continue
-                        
-                    target_path = (scenario_path / "inputs") if input_files_only else scenario_path
-                    prefix = f"{scenario}/inputs" if input_files_only else scenario
-                    
-                    for item_path in target_path.rglob('*'):
-                        if item_path.is_file() and item_path.suffix in VALID_EXTENSIONS:
-                            relative_path = str(Path(prefix) / item_path.relative_to(target_path))
-                            zip_file.write(item_path, arcname=relative_path)
+
+                    input_paths = (scenario_path / "inputs")
+                    if input_files and input_paths.exists():
+                        for root, dirs, files in os.walk(input_paths):
+                            root_path = Path(root)
+                            for file in files:
+                                if Path(file).suffix in VALID_EXTENSIONS:
+                                    item_path = root_path / file
+                                    relative_path = str(Path(scenario_name) / "inputs" / item_path.relative_to(input_paths))
+                                    files_to_zip.append((item_path, relative_path))
+
+                    output_paths = (scenario_path / "outputs")
+                    if output_files_level == "detailed" and output_paths.exists():
+                        for root, dirs, files in os.walk(output_paths):
+                            root_path = Path(root)
+                            for file in files:
+                                if Path(file).suffix in VALID_EXTENSIONS:
+                                    item_path = root_path / file
+                                    relative_path = str(Path(scenario_name) / "outputs" / item_path.relative_to(output_paths))
+                                    files_to_zip.append((item_path, relative_path))
+
+                    elif output_files_level == "summary":
+                        # create summary files first
+                        await run_in_threadpool(run_summary, str(base_path), scenario_name)
+
+                        export_paths = (scenario_path / "export" / "results")
+                        if not export_paths.exists():
+                            raise ValueError(f"Export results path does not exist for scenario {scenario_name}")
+
+                        for root, dirs, files in os.walk(export_paths):
+                            root_path = Path(root)
+                            for file in files:
+                                if Path(file).suffix in VALID_EXTENSIONS:
+                                    item_path = root_path / file
+                                    relative_path = str(
+                                        Path(scenario_name) / "export" / "results" / item_path.relative_to(export_paths))
+                                    files_to_zip.append((item_path, relative_path))
+                
+                # Batch write all files to zip
+                logger.info(f"Writing {len(files_to_zip)} files to zip...")
+                for item_path, archive_name in files_to_zip:
+                    zip_file.write(item_path, arcname=archive_name)
 
         # Get the file size for Content-Length header
         file_size = os.path.getsize(temp_file_path)
-        
+
         # Define the streaming function
         async def file_streamer():
             try: