buildstock-fetch 1.0.1__py3-none-any.whl → 1.0.3__py3-none-any.whl

buildstock_fetch/main.py

@@ -1,6 +1,5 @@
 import concurrent.futures
 import json
-import os
 import zipfile
 from dataclasses import asdict, dataclass
 from importlib.resources import files
@@ -211,9 +210,8 @@ def _validate_release_name(release_name: str) -> bool:
         True if the release name is valid, False otherwise.
     """
     # Read the valid release names from the JSON file
-    releases_file = files("buildstock_fetch.utils").joinpath("buildstock_releases.json")
-    with open(str(releases_file)) as f:
-        releases_data = json.load(f)
+    releases_file = files("buildstock_fetch").joinpath("data").joinpath("buildstock_releases.json")
+    releases_data = json.loads(Path(str(releases_file)).read_text(encoding="utf-8"))
 
     # Get the top-level keys as valid release names
     valid_release_names = list(releases_data.keys())
@@ -239,7 +237,7 @@ def fetch_bldg_ids(
     """
     # Construct the absolute path to the parquet directory
     parquet_dir = Path(
-        str(files("buildstock_fetch.utils").joinpath("building_data").joinpath("combined_metadata.parquet"))
+        str(files("buildstock_fetch").joinpath("data").joinpath("building_data").joinpath("combined_metadata.parquet"))
     )
 
     if product == "resstock":
@@ -304,7 +302,8 @@ def _download_with_progress(url: str, output_file: Path, progress: Progress, tas
 
     downloaded_size = 0
 
-    with open(output_file, "wb") as file:
+    # For streaming downloads, we still need the traditional approach for progress tracking
+    with open(str(output_file), "wb") as file:
         for chunk in response.iter_content(chunk_size=8192):
             if chunk:
                 file.write(chunk)
@@ -337,7 +336,7 @@ def download_bldg_data(
     if isinstance(output_dir, str):
         output_dir = Path(output_dir)
     if not output_dir.exists():
-        os.makedirs(output_dir, exist_ok=True)
+        output_dir.mkdir(parents=True, exist_ok=True)
 
     # Create a unique temporary directory for this building to avoid race conditions
     temp_dir = output_dir / f"temp_{str(bldg_id.bldg_id).zfill(7)}_{bldg_id.upgrade_id}"
@@ -361,8 +360,7 @@ def download_bldg_data(
         else:
             response = requests.get(download_url, timeout=30)
             response.raise_for_status()
-            with open(output_file, "wb") as file:
-                file.write(response.content)
+            output_file.write_bytes(response.content)
 
         # Extract specific files based on file_type
         with zipfile.ZipFile(output_file, "r") as zip_ref:
@@ -419,8 +417,7 @@ def download_metadata(bldg_id: BuildingID, output_dir: Path) -> Path:
     response.raise_for_status()
     output_file = output_dir / bldg_id.get_release_name() / "metadata" / bldg_id.state / "metadata.parquet"
     output_file.parent.mkdir(parents=True, exist_ok=True)
-    with open(output_file, "wb") as file:
-        file.write(response.content)
+    output_file.write_bytes(response.content)
     return output_file
 
 
@@ -446,8 +443,7 @@ def download_15min_load_curve(bldg_id: BuildingID, output_dir: Path) -> Path:
         / f"bldg{str(bldg_id.bldg_id).zfill(7)}-up{str(int(bldg_id.upgrade_id)).zfill(2)}_load_curve_15min.parquet"
     )
     output_file.parent.mkdir(parents=True, exist_ok=True)
-    with open(output_file, "wb") as file:
-        file.write(response.content)
+    output_file.write_bytes(response.content)
     return output_file
 
 
@@ -485,8 +481,7 @@ def download_15min_load_curve_with_progress(
     else:
         response = requests.get(download_url, timeout=30)
         response.raise_for_status()
-        with open(output_file, "wb") as file:
-            file.write(response.content)
+        output_file.write_bytes(response.content)
 
     return output_file
 

buildstock_fetch/main_cli.py

@@ -27,7 +27,7 @@ app = typer.Typer(
 
 
 # File configuration
-BUILDSTOCK_RELEASES_FILE = str(files("buildstock_fetch.utils").joinpath("buildstock_releases.json"))
+BUILDSTOCK_RELEASES_FILE = str(files("buildstock_fetch").joinpath("data").joinpath("buildstock_releases.json"))
 
 
 class InvalidProductError(Exception):
@@ -219,16 +219,14 @@ def _get_file_type_options_grouped(release_name: str) -> list[dict]:
 
 def _get_available_releases_names() -> list[str]:
     # Read the buildstock releases JSON file
-    with open(BUILDSTOCK_RELEASES_FILE) as f:
-        buildstock_releases = json.load(f)
+    buildstock_releases = json.loads(Path(BUILDSTOCK_RELEASES_FILE).read_text(encoding="utf-8"))
 
     # Return the top-level keys as release options
     return list(buildstock_releases.keys())
 
 
 def _get_all_available_releases() -> dict[str, dict]:
-    with open(BUILDSTOCK_RELEASES_FILE) as f:
-        buildstock_releases = json.load(f)
+    buildstock_releases = json.loads(Path(BUILDSTOCK_RELEASES_FILE).read_text(encoding="utf-8"))
     return cast(dict[str, dict], buildstock_releases)
 
 

{buildstock_fetch-1.0.1.dist-info → buildstock_fetch-1.0.3.dist-info}/METADATA

@@ -1,8 +1,8 @@
 Metadata-Version: 2.4
 Name: buildstock-fetch
-Version: 1.0.1
+Version: 1.0.3
 Summary: This library simplifies downloading building characteristics and load curve data from NREL's ResStock and ComStock projects.
-Author-email: Switchbox <bryan@switch.box>
+Author-email: Switchbox <hello@switch.box>
 Project-URL: Homepage, https://switchbox-data.github.io/buildstock-fetch/
 Project-URL: Repository, https://github.com/switchbox-data/buildstock-fetch
 Project-URL: Documentation, https://switchbox-data.github.io/buildstock-fetch/
@@ -23,12 +23,7 @@ Requires-Dist: requests>=2.32.3
 Requires-Dist: typer>=0.9.0
 Requires-Dist: rich>=13.9.5
 Requires-Dist: questionary>=1.11.0
-Requires-Dist: pandas>=2.0.0
-Requires-Dist: boto3>=1.33.0
-Requires-Dist: botocore>=1.33.0
-Requires-Dist: pyarrow>=14.0.1
 Requires-Dist: polars>=0.20.0
-Requires-Dist: numpy>=1.26.4
 Dynamic: license-file
 
 # buildstock-fetch
@@ -43,9 +38,9 @@ This library simplifies downloading building characteristics and load curve data
 - **Github repository**: <https://github.com/switchbox-data/buildstock-fetch/>
 - **Documentation** <https://switchbox-data.github.io/buildstock-fetch/>
 
-## Using the library
+## Installing the library
 
-`buildstock-fetch` is available on PyPI and can be installed via:
+`buildstock-fetch` is available on [PyPI](https://pypi.org/project/buildstock-fetch/) and can be installed via:
 
 ```bash
 pip install buildstock-fetch
@@ -57,6 +52,27 @@ or
 uv pip install buildstock-fetch
 ```
 
+## Using the library
+
+To use the CLI tool in `buildstock-fetch` run:
+
+```bash
+bsf
+```
+
+to activate the interactive mode. Alternatively, provide the inputs directly. For example,
+
+```bash
+bsf --product resstock --release_year 2022 --weather_file tmy3 --release_version 1 --states CA --file_type "hpxml metadata" --upgrade_id "0 1 2" --output_directory ./CA_data
+```
+
+If the above options don't work, try:
+
+```bash
+python -m buildstock_fetch
+```
+
+For more details about the usage, see [Usage](https://switchbox-data.github.io/buildstock-fetch/usage/)
 
 ## Developing the library
 

buildstock_fetch-1.0.3.dist-info/RECORD

@@ -0,0 +1,10 @@
+buildstock_fetch/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+buildstock_fetch/__main__.py,sha256=wEPNJ-s7F6KcRQ_4B5Xh08uqvYZHno5F2R8DU0BMBtk,80
+buildstock_fetch/main.py,sha256=AK86qh4e6Sf5WSQZcBRNytGQXt9T8oHoarJU4tiVgdo,28814
+buildstock_fetch/main_cli.py,sha256=3JEy5h00c0vtEgjgPbfY35NNVRmfMleHut9v-FDl1wo,26865
+buildstock_fetch-1.0.3.dist-info/licenses/LICENSE,sha256=TJeh2yvO8__8Rbamd8r48-zvlFCINAsu9nOo5QdMRX8,1066
+buildstock_fetch-1.0.3.dist-info/METADATA,sha256=jEa0QHSoVMKl7ne1XDHjDd6zJudTVMs8ko_RrRmdhj8,6446
+buildstock_fetch-1.0.3.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+buildstock_fetch-1.0.3.dist-info/entry_points.txt,sha256=C7zPk3BSLcI47ymvYKI05nvfRJMEXz4BPIIDKsjePn8,54
+buildstock_fetch-1.0.3.dist-info/top_level.txt,sha256=-PGb2C-Tb3O-wPqUHSOBrvJqRzNHgY_KTbTsXaHIo5M,17
+buildstock_fetch-1.0.3.dist-info/RECORD,,

{buildstock_fetch-1.0.1.dist-info → buildstock_fetch-1.0.3.dist-info}/top_level.txt

@@ -1,3 +1 @@
 buildstock_fetch
-tests
-utils

buildstock_fetch/ev_demand.py

@@ -1,422 +0,0 @@
-from dataclasses import dataclass
-from datetime import datetime
-from pathlib import Path
-from typing import Final, Optional
-
-import numpy as np
-import polars as pl
-
-from buildstock_fetch.utils import ev_utils
-
-BASEPATH: Final[Path] = Path(__file__).resolve().parents[1]
-
-
-class MetadataPathError(Exception):
-    """Raised when no metadata path is provided."""
-
-    pass
-
-
-class MetadataDataFrameError(Exception):
-    """Raised when no metadata DataFrame is available."""
-
-    pass
-
-
-class VehicleOwnershipModelError(Exception):
-    """Raised when vehicle ownership model is not fitted."""
-
-    pass
-
-
-class NHTSDataError(Exception):
-    """Raised when NHTS data is not loaded."""
-
-    pass
-
-
-class WeatherDataError(Exception):
-    """Raised when weather data is not loaded."""
-
-    pass
-
-
-@dataclass
-class EVDemandConfig:
-    state: str
-    release: str
-    metadata_path: Optional[str] = None
-    pums_path: Optional[str] = None
-    nhts_path: str = f"{BASEPATH}/utils/ev_data/inputs/NHTS_v2_1_trip_surveys.csv"
-    weather_path: Optional[str] = None
-    output_dir: Optional[Path] = None
-
-    def __post_init__(self) -> None:
-        if self.metadata_path is None:
-            self.metadata_path = f"{Path(__file__).parent}/data/{self.release}/metadata/{self.state}/metadata.parquet"
-        if self.pums_path is None:
-            self.pums_path = f"{BASEPATH}/utils/ev_data/inputs/{self.state}_2021_pums_PUMA_HINCP_VEH_NP.csv"
-        if self.weather_path is None:
-            self.weather_path = f"{BASEPATH}//data/{self.release}/weather.csv"
-
-
-@dataclass
-class VehicleProfile:
-    """Represents a vehicle's driving profile parameters."""
-
-    building_id: int
-    vehicle_id: int
-    weekday_departure_hour: int
-    weekday_arrival_hour: int
-    weekday_miles: float
-    weekend_departure_hour: int
-    weekend_arrival_hour: int
-    weekend_miles: float
-
-
-@dataclass
-class TripSchedule:
-    """Represents a daily trip schedule for a vehicle."""
-
-    building_id: int
-    vehicle_id: int
-    date: datetime
-    departure_hour: int
-    arrival_hour: int
-    miles_driven: float
-    avg_temp_while_away: float
-    kwh_consumed: float
-
-
-class EVDemandCalculator:
-    """
-    Calculator for EV demand based on ResStock metadata, PUMS data, and NHTS trip data.
-
-    This class implements the workflow described in the methodology:
-    1. Load ResStock metadata
-    2. Fit vehicle ownership model using PUMS data
-    3. Predict number of vehicles per household
-    4. Sample vehicle driving profiles from NHTS
-    5. Generate annual trip schedules
-    6. Convert miles to kWh using temperature-dependent efficiency
-    7. Assign battery capacities
-    """
-
-    def __init__(
-        self,
-        metadata_df: pl.DataFrame,
-        nhts_df: Optional[pl.DataFrame] = None,
-        weather_df: Optional[pl.DataFrame] = None,
-    ):
-        """
-        Initialize the EV demand calculator.
-
-        Args:
-            metadata_df: ResStock metadata DataFrame
-            nhts_df: NHTS trip data DataFrame (optional)
-            weather_df: Weather data DataFrame (optional)
-        """
-        self.metadata_df = metadata_df
-        self.nhts_df = nhts_df
-        self.weather_df = weather_df
-        self.vehicle_ownership_model: Optional[object] = None
-
-        # Available battery capacities in kWh
-        self.battery_capacities = [12, 40, 60, 90, 120]
-
-        # Yuksel and Michalek (2015) polynomial coefficients for energy consumption
-        # c(T) = sum(a_n * T^n) for n=0 to 5, units: kWh/mi/°F^n
-        self.efficiency_coefficients = np.array([
-            0.3950,  # a_0 (constant term)
-            -0.0022,  # a_1 (linear term)
-            9.1978e-5,  # a_2 (quadratic term)
-            -3.9249e-6,  # a_3 (cubic term)
-            5.2918e-8,  # a_4 (quartic term)
-            -2.0659e-10,  # a_5 (quintic term)
-        ])
-
-    def fit_vehicle_ownership_model(self, pums_df: pl.DataFrame) -> object:
-        """
-        Fit a model to predict number of vehicles per household using PUMS data.
-
-        Args:
-            pums_df: DataFrame with PUMS household data, including 'occupants', 'inc', 'metro_area', 'num_vehicles'
-
-        Returns:
-            Trained model object
-        """
-        # TODO: Implement multinomial logistic regression or similar
-        # This is a placeholder - replace with actual model fitting
-        self.vehicle_ownership_model = "placeholder_model"
-        return self.vehicle_ownership_model
-
-    def predict_num_vehicles(self, metadata_df: Optional[pl.DataFrame] = None) -> pl.DataFrame:
-        """
-        Predict number of vehicles for each household in the metadata using the fitted model.
-
-        Args:
-            metadata_df: DataFrame with ResStock metadata. If None, uses self.metadata_df
-
-        Returns:
-            DataFrame with an added 'num_vehicles' column
-        """
-        df = metadata_df or self.metadata_df
-        if df is None:
-            raise MetadataDataFrameError()
-
-        if self.vehicle_ownership_model is None:
-            raise VehicleOwnershipModelError()
-
-        # TODO: Implement actual prediction logic
-        # This is a placeholder - replace with actual model prediction
-        df = df.with_columns(pl.lit(1).alias("num_vehicles"))  # Placeholder: assume 1 vehicle per household
-        return df
-
-    def sample_vehicle_profiles(
-        self, metadata_df: Optional[pl.DataFrame] = None
-    ) -> dict[tuple[int, int], VehicleProfile]:
-        """
-        For each household and vehicle, sample weekday and weekend trip profiles from NHTS.
-
-        Args:
-            metadata_df: DataFrame with household and vehicle info. If None, uses self.metadata_df
-
-        Returns:
-            Dict mapping (building_id, vehicle_id) to sampled trip profile parameters
-        """
-        df = self.metadata_df
-        if df is None:
-            raise MetadataDataFrameError()
-
-        if self.nhts_df is None:
-            raise NHTSDataError()
-
-        # TODO: Implement NHTS sampling logic
-        # This is a placeholder - replace with actual sampling logic
-        profiles = {}
-        for row in df.iter_rows(named=True):
-            building_id = row["building_id"]
-            num_vehicles = row.get("num_vehicles", 1)
-
-            for vehicle_id in range(num_vehicles):
-                profiles[(building_id, vehicle_id)] = VehicleProfile(
-                    building_id=building_id,
-                    vehicle_id=vehicle_id,
-                    weekday_departure_hour=8,
-                    weekday_arrival_hour=18,
-                    weekday_miles=30.0,
-                    weekend_departure_hour=10,
-                    weekend_arrival_hour=16,
-                    weekend_miles=20.0,
-                )
-
-        return profiles
-
-    def get_avg_temp_while_away(self, departure_hour: int, arrival_hour: int, date: datetime) -> float:
-        """
-        Calculate the average outdoor temperature during the hours the vehicle is away from home.
-
-        Args:
-            departure_hour: Hour vehicle leaves home
-            arrival_hour: Hour vehicle returns home
-            date: The date for which to compute the average
-
-        Returns:
-            Average temperature during vehicle absence
-        """
-        if self.weather_df is None:
-            raise WeatherDataError()
-
-        # TODO: Implement temperature calculation logic
-        # This is a placeholder - replace with actual temperature calculation
-        return 70.0  # Placeholder: assume 70°F average
-
-    def miles_to_kwh(self, daily_miles: float, avg_temp: float) -> float:
-        """
-        Calculate daily electricity consumption for electric vehicles based on
-        temperature and daily miles driven using the Yuksel and Michalek (2015) regression. @yuksel_EffectsRegionalTemperature_2015
-
-        Args:
-            daily_miles: Number of miles driven in a day
-            avg_temp: Average outdoor temperature during driving hours (in °F)
-
-        Returns:
-            Daily electricity consumption in kWh
-        """
-        # Convert inputs to numpy arrays for vectorized operations
-        temp = np.asarray(avg_temp)
-        miles = np.asarray(daily_miles)
-
-        # Apply temperature bounds as described in the paper
-        temp_bounded = np.clip(temp, -15, 110)
-
-        # Calculate energy consumption per mile using polynomial regression
-        # c(T) = a_0 + a_1*T + a_2*T^2 + a_3*T^3 + a_4*T^4 + a_5*T^5
-        # polyval expects coefficients in reverse order
-        consumption_per_mile = np.polyval(self.efficiency_coefficients[::-1], temp_bounded)
-
-        # Calculate total daily energy consumption
-        daily_consumption_kwh = consumption_per_mile * miles
-
-        # Return scalar if input was scalar
-        if np.isscalar(daily_miles) and np.isscalar(avg_temp):
-            return float(daily_consumption_kwh)
-        return float(daily_consumption_kwh)
-
-    def generate_annual_trip_schedule(
-        self,
-        profile_params: dict[tuple[int, int], VehicleProfile],
-        start_date: str = "2022-01-01",
-        end_date: str = "2022-12-31",
-    ) -> pl.DataFrame:
-        """
-        Generate an annual trip schedule for each vehicle based on sampled parameters.
-
-        Args:
-            profile_params: Dict of sampled trip profile parameters
-            start_date: Start date for the annual schedule
-            end_date: End date for the annual schedule
-
-        Returns:
-            DataFrame with daily departure/arrival times and miles driven for each vehicle
-        """
-        # TODO: Implement annual schedule generation
-        # This is a placeholder - replace with actual schedule generation logic
-        schedules = []
-
-        # Parse start date once
-        start_datetime = datetime(2022, 1, 1)  # Fixed date for placeholder
-
-        for (building_id, vehicle_id), profile in profile_params.items():
-            # Placeholder: generate one day of data
-            schedule = TripSchedule(
-                building_id=building_id,
-                vehicle_id=vehicle_id,
-                date=start_datetime,
-                departure_hour=profile.weekday_departure_hour,
-                arrival_hour=profile.weekday_arrival_hour,
-                miles_driven=profile.weekday_miles,
-                avg_temp_while_away=self.get_avg_temp_while_away(
-                    profile.weekday_departure_hour, profile.weekday_arrival_hour, start_datetime
-                ),
-                kwh_consumed=0.0,  # Will be calculated below
-            )
-
-            # Calculate kWh consumed
-            schedule.kwh_consumed = self.miles_to_kwh(schedule.miles_driven, schedule.avg_temp_while_away)
-
-            schedules.append(schedule)
-
-        # Convert to DataFrame
-        return pl.DataFrame([vars(schedule) for schedule in schedules])
-
-    def assign_battery_capacity(self, daily_kwh: pl.Series) -> pl.Series:
-        """
-        Assign the minimum EV battery capacity that covers the max daily kWh plus a 20% buffer.
-
-        Args:
-            daily_kwh: Series of max daily kWh for each vehicle
-
-        Returns:
-            Series of assigned battery capacities (12, 40, 60, 90, 120 kWh)
-        """
-        # Calculate required capacity with 20% buffer
-        required_capacity = daily_kwh * 1.2
-
-        # Find the minimum battery capacity that meets the requirement
-        battery_capacities = pl.Series(self.battery_capacities)
-        assigned_capacities: list[int] = []
-
-        for required in required_capacity:
-            # Find the smallest battery that can handle the required capacity
-            suitable_batteries = battery_capacities.filter(battery_capacities >= required)
-            if len(suitable_batteries) > 0:
-                assigned_capacities.append(int(suitable_batteries[0]))
-            else:
-                # If no battery is large enough, assign the largest available
-                assigned_capacities.append(int(battery_capacities[-1]))
-
-        return pl.Series(assigned_capacities)
-
-    # def run_complete_workflow(
-    #     self, pums_path: str, nhts_path: str, weather_path: str, output_dir: Optional[Path] = None
-    # ) -> dict[str, Union[pl.DataFrame, pl.Series]]:
-    #     """
-    #     Run the complete EV demand workflow.
-
-    #     Args:
-    #         pums_path: Path to PUMS data file
-    #         nhts_path: Path to NHTS data file
-    #         weather_path: Path to weather data file
-    #         output_dir: Directory to save output files
-
-    #     Returns:
-    #         Dictionary containing all output DataFrames and Series
-    #     """
-    #     # Step 1: Load metadata
-    #     metadata_df = self.load_metadata()
-
-    #     # Step 2: Load PUMS data and fit vehicle ownership model
-    #     pums_df = pl.read_csv(pums_path)  # TODO: Adjust based on actual PUMS format
-    #     self.fit_vehicle_ownership_model(pums_df)
-
-    #     # Step 3: Predict number of vehicles
-    #     metadata_with_vehicles = self.predict_num_vehicles(metadata_df)
-
-    #     # Step 4: Load NHTS data
-    #     self.load_nhts_data(nhts_path)
-
-    #     # Step 5: Load weather data
-    #     self.load_weather_data(weather_path)
-
-    #     # Step 6: Sample vehicle profiles
-    #     vehicle_profiles = self.sample_vehicle_profiles(metadata_with_vehicles)
-
-    #     # Step 7: Generate annual trip schedules
-    #     trip_schedules = self.generate_annual_trip_schedule(vehicle_profiles)
-
-    #     # Step 8: Assign battery capacities
-    #     max_daily_kwh = trip_schedules.group_by(["building_id", "vehicle_id"]).agg(pl.col("kwh_consumed").max())
-    #     battery_capacities = self.assign_battery_capacity(max_daily_kwh.get_column("kwh_consumed"))
-
-    #     # Save outputs if output_dir is provided
-    #     if output_dir:
-    #         output_dir = Path(output_dir)
-    #         output_dir.mkdir(exist_ok=True)
-
-    #         metadata_with_vehicles.write_csv(output_dir / "metadata_with_vehicles.csv")
-    #         trip_schedules.write_csv(output_dir / "trip_schedules.csv")
-    #         battery_capacities.to_frame().write_csv(output_dir / "battery_capacities.csv")
-
-    #     return {
-    #         "metadata_with_vehicles": metadata_with_vehicles,
-    #         "trip_schedules": trip_schedules,
-    #         "battery_capacities": battery_capacities,
-    #     }
-
-
-# Example usage
-if __name__ == "__main__":
-    # Step 1: Create configuration
-    config = EVDemandConfig(state="NY", release="resstock_tmy3_release_1")
-
-    # Step 2: Load all data
-    metadata_df, nhts_df, pums_df, weather_df = ev_utils.load_all_input_data(config)
-    print(f"✓ Loaded metadata: {len(metadata_df)} rows")
-    print(f"✓ Loaded NHTS data: {len(nhts_df)} rows")
-    print(f"✓ Loaded weather data: {len(weather_df)} rows")
-
-    # # Step 3: Initialize calculator with data
-    # calculator = EVDemandCalculator(
-    #     metadata_df=metadata_df,
-    #     nhts_df=nhts_df,
-    #     weather_df=weather_df
-    # )
-
-    # print(f"✓ Initialized calculator")
-    # print(f"  - Battery capacities: {calculator.battery_capacities}")
-    # print(
-    #     f"  - Efficiency coefficients: {len(calculator.efficiency_coefficients)} terms")
-
-    # # Step 4: Run calculations (placeholder for now)
-    # print("Ready to run EV demand calculations!")

buildstock_fetch/utils/__init__.py

@@ -1 +0,0 @@
-# This file makes buildstock_fetch.utils a Python package