voxcity 0.6.18__py3-none-any.whl → 0.6.20__py3-none-any.whl

voxcity/generator.py

@@ -921,8 +921,22 @@ def get_voxcity_CityGML(rectangle_vertices, land_cover_source, canopy_height_sou
     # Remove 'output_dir' from kwargs to prevent duplication
     kwargs.pop('output_dir', None)
 
+    # SSL/HTTP options for CityGML download (optional)
+    # Backward compatible: accept 'verify' but prefer 'ssl_verify'
+    ssl_verify = kwargs.pop('ssl_verify', kwargs.pop('verify', True))
+    ca_bundle = kwargs.pop('ca_bundle', None)
+    timeout = kwargs.pop('timeout', 60)
+
     # get all required gdfs    
-    building_gdf, terrain_gdf, vegetation_gdf = load_buid_dem_veg_from_citygml(url=url_citygml, citygml_path=citygml_path, base_dir=output_dir, rectangle_vertices=rectangle_vertices)
+    building_gdf, terrain_gdf, vegetation_gdf = load_buid_dem_veg_from_citygml(
+        url=url_citygml,
+        citygml_path=citygml_path,
+        base_dir=output_dir,
+        rectangle_vertices=rectangle_vertices,
+        ssl_verify=ssl_verify,
+        ca_bundle=ca_bundle,
+        timeout=timeout
+    )
 
     # Normalize CRS to WGS84 (EPSG:4326) to ensure consistent operations downstream
     try:

voxcity/simulator/solar.py

@@ -1007,10 +1007,15 @@ def get_global_solar_irradiance_using_epw(
                 output_dir=output_dir,
                 max_distance=max_distance,
                 extract_zip=True,
-                load_data=True
+                load_data=True,
+                allow_insecure_ssl=kwargs.get("allow_insecure_ssl", False),
+                allow_http_fallback=kwargs.get("allow_http_fallback", False),
+                ssl_verify=kwargs.get("ssl_verify", True)
             )
 
     # Read EPW data
+    if epw_file_path is None:
+        raise RuntimeError("EPW file path is None. Set 'epw_file_path' or enable 'download_nearest_epw' and ensure network succeeds.")
     df, lon, lat, tz, elevation_m = read_epw_for_solar_simulation(epw_file_path)
     if df.empty:
         raise ValueError("No data in EPW file.")
@@ -2030,10 +2035,15 @@ def get_building_global_solar_irradiance_using_epw(
                 output_dir=output_dir,
                 max_distance=max_distance,
                 extract_zip=True,
-                load_data=True
+                load_data=True,
+                allow_insecure_ssl=kwargs.get("allow_insecure_ssl", False),
+                allow_http_fallback=kwargs.get("allow_http_fallback", False),
+                ssl_verify=kwargs.get("ssl_verify", True)
             )
 
     # Read EPW data
+    if epw_file_path is None:
+        raise RuntimeError("EPW file path is None. Set 'epw_file_path' or enable 'download_nearest_epw' and ensure network succeeds.")
     df, lon, lat, tz, elevation_m = read_epw_for_solar_simulation(epw_file_path)
     if df.empty:
         raise ValueError("No data in EPW file.")

voxcity/utils/weather.py

@@ -209,7 +209,9 @@ def process_epw(epw_path: Union[str, Path]) -> Tuple[pd.DataFrame, Dict]:
 # =============================================================================
 
 def get_nearest_epw_from_climate_onebuilding(longitude: float, latitude: float, output_dir: str = "./", max_distance: Optional[float] = None, 
-                extract_zip: bool = True, load_data: bool = True, region: Optional[Union[str, List[str]]] = None) -> Tuple[Optional[str], Optional[pd.DataFrame], Optional[Dict]]:
+                extract_zip: bool = True, load_data: bool = True, region: Optional[Union[str, List[str]]] = None,
+                allow_insecure_ssl: bool = False, allow_http_fallback: bool = False,
+                ssl_verify: Union[bool, str] = True) -> Tuple[Optional[str], Optional[pd.DataFrame], Optional[Dict]]:
     """
     Download and process EPW weather file from Climate.OneBuilding.Org based on coordinates.
     
@@ -233,11 +235,19 @@ def get_nearest_epw_from_climate_onebuilding(longitude: float, latitude: float,
                                        If no stations within this distance, uses closest available.
         extract_zip (bool): Whether to extract the ZIP file (default True)
         load_data (bool): Whether to load the EPW data into a DataFrame (default True)
-        region (str or List[str], optional): Specific region(s) to scan for stations.
-                                            Options: "Africa", "Asia", "Japan", "India", "Argentina",
-                                            "Canada", "USA", "Caribbean", "Southwest_Pacific", 
-                                            "Europe", "Antarctica", or "all".
+        region (str or List[str], optional): Specific region(s) or dataset(s) to scan for stations.
+                                            Regions: "Africa", "Asia", "South_America",
+                                            "North_and_Central_America", "Southwest_Pacific",
+                                            "Europe", "Antarctica".
+                                            Sub-datasets (can be used alone or auto-included by region):
+                                            "Japan", "India", "CSWD", "CityUHK", "PHIKO",
+                                            "Argentina", "INMET_TRY", "AMTUes", "BrazFuture",
+                                            plus legacy "Canada", "USA", "Caribbean" (Region 4).
+                                            Use "all" to scan every dataset.
                                             If None, will auto-detect region based on coordinates.
+            allow_insecure_ssl (bool): If True, on SSL errors retry with certificate verification disabled.
+            allow_http_fallback (bool): If True, on SSL/network errors, also try HTTP (insecure) fallback.
+            ssl_verify (bool|str): Passed to requests as 'verify' parameter for HTTPS; can be False or CA bundle path.
     
     Returns:
         Tuple containing:
@@ -250,35 +260,83 @@ def get_nearest_epw_from_climate_onebuilding(longitude: float, latitude: float,
         requests.exceptions.RequestException: If network requests fail
     """
     
-    # Regional KML sources from Climate.OneBuilding.Org
-    # Each region maintains its own KML file with weather station locations and metadata
+    # Regional KML sources from Climate.OneBuilding.Org (2024+ TMYx structure)
+    # Each WMO region maintains a primary KML in /sources with the naming pattern:
+    #   Region{N}_{Name}_TMYx_EPW_Processing_locations.kml
+    # Keep sub-region keys for backward compatibility (mapping to the Region KML where applicable)
     KML_SOURCES = {
-        "Africa": "https://climate.onebuilding.org/WMO_Region_1_Africa/Region1_Africa_EPW_Processing_locations.kml",
-        "Asia": "https://climate.onebuilding.org/WMO_Region_2_Asia/Region2_Asia_EPW_Processing_locations.kml",
+        # WMO Region 1
+        "Africa": "https://climate.onebuilding.org/sources/Region1_Africa_TMYx_EPW_Processing_locations.kml",
+        # WMO Region 2
+        "Asia": "https://climate.onebuilding.org/sources/Region2_Asia_TMYx_EPW_Processing_locations.kml",
+        # Subsets/datasets within Asia that still publish dedicated KMLs
         "Japan": "https://climate.onebuilding.org/sources/JGMY_EPW_Processing_locations.kml",
         "India": "https://climate.onebuilding.org/sources/ITMY_EPW_Processing_locations.kml",
+        "CSWD": "https://climate.onebuilding.org/sources/CSWD_EPW_Processing_locations.kml",
+        "CityUHK": "https://climate.onebuilding.org/sources/CityUHK_EPW_Processing_locations.kml",
+        "PHIKO": "https://climate.onebuilding.org/sources/PHIKO_EPW_Processing_locations.kml",
+        # WMO Region 3
+        "South_America": "https://climate.onebuilding.org/sources/Region3_South_America_TMYx_EPW_Processing_locations.kml",
+        # Historical/legacy dataset for Argentina maintained separately
         "Argentina": "https://climate.onebuilding.org/sources/ArgTMY_EPW_Processing_locations.kml",
+        "INMET_TRY": "https://climate.onebuilding.org/sources/INMET_TRY_EPW_Processing_locations.kml",
+        "AMTUes": "https://climate.onebuilding.org/sources/AMTUes_EPW_Processing_locations.kml",
+        "BrazFuture": "https://climate.onebuilding.org/sources/BrazFuture_EPW_Processing_locations.kml",
+        # WMO Region 4 (use subregion KMLs; umbrella selection expands to these)
+        # Note: There is no single unified Region 4 KML in /sources as of 2024.
+        # Use these three subregion KMLs instead.
         "Canada": "https://climate.onebuilding.org/sources/Region4_Canada_TMYx_EPW_Processing_locations.kml",
         "USA": "https://climate.onebuilding.org/sources/Region4_USA_TMYx_EPW_Processing_locations.kml",
         "Caribbean": "https://climate.onebuilding.org/sources/Region4_NA_CA_Caribbean_TMYx_EPW_Processing_locations.kml",
+        # WMO Region 5
         "Southwest_Pacific": "https://climate.onebuilding.org/sources/Region5_Southwest_Pacific_TMYx_EPW_Processing_locations.kml",
+        # WMO Region 6
         "Europe": "https://climate.onebuilding.org/sources/Region6_Europe_TMYx_EPW_Processing_locations.kml",
-        "Antarctica": "https://climate.onebuilding.org/sources/Region7_Antarctica_TMYx_EPW_Processing_locations.kml"
+        # WMO Region 7
+        "Antarctica": "https://climate.onebuilding.org/sources/Region7_Antarctica_TMYx_EPW_Processing_locations.kml",
+    }
+
+    # Group region selections to include relevant sub-datasets automatically
+    REGION_DATASET_GROUPS = {
+        "Africa": ["Africa"],
+        "Asia": ["Asia", "Japan", "India", "CSWD", "CityUHK", "PHIKO"],
+        "South_America": ["South_America", "Argentina", "INMET_TRY", "AMTUes", "BrazFuture"],
+        "North_and_Central_America": ["North_and_Central_America", "Canada", "USA", "Caribbean"],
+        "Southwest_Pacific": ["Southwest_Pacific"],
+        "Europe": ["Europe"],
+        "Antarctica": ["Antarctica"],
     }
     
     # Define approximate geographical boundaries for automatic region detection
     # These bounds help determine which regional KML files to scan based on coordinates
     REGION_BOUNDS = {
-        "Africa": {"lon_min": -20, "lon_max": 55, "lat_min": -35, "lat_max": 40},
-        "Asia": {"lon_min": 25, "lon_max": 150, "lat_min": 0, "lat_max": 55},
+        # WMO Region 1 - Africa (includes islands in Indian Ocean and Spanish territories off N. Africa)
+        "Africa": {"lon_min": -25, "lon_max": 80, "lat_min": -55, "lat_max": 45},
+        # WMO Region 2 - Asia (includes SE Asia, West Asia, Asian Russia, and BIOT)
+        "Asia": {"lon_min": 20, "lon_max": 180, "lat_min": -10, "lat_max": 80},
+        # Subsets
         "Japan": {"lon_min": 127, "lon_max": 146, "lat_min": 24, "lat_max": 46},
         "India": {"lon_min": 68, "lon_max": 97, "lat_min": 6, "lat_max": 36},
+        # WMO Region 3 - South America (includes Falklands, South Georgia/Sandwich, Galapagos)
+        "South_America": {"lon_min": -92, "lon_max": -20, "lat_min": -60, "lat_max": 15},
+        # Legacy/compatibility subset
         "Argentina": {"lon_min": -75, "lon_max": -53, "lat_min": -55, "lat_max": -22},
+        # WMO Region 4 - North and Central America (includes Greenland and Caribbean)
+        "North_and_Central_America": {"lon_min": -180, "lon_max": 20, "lat_min": -10, "lat_max": 85},
+        # Backward-compatible subsets mapped to Region 4 KML
         "Canada": {"lon_min": -141, "lon_max": -52, "lat_min": 42, "lat_max": 83},
         "USA": {"lon_min": -170, "lon_max": -65, "lat_min": 20, "lat_max": 72},
         "Caribbean": {"lon_min": -90, "lon_max": -59, "lat_min": 10, "lat_max": 27},
-        "Southwest_Pacific": {"lon_min": 110, "lon_max": 180, "lat_min": -50, "lat_max": 0},
-        "Europe": {"lon_min": -25, "lon_max": 40, "lat_min": 35, "lat_max": 72},
+        # WMO Region 5 - Southwest Pacific (covers SE Asia + Pacific islands + Hawaii via antimeridian)
+        "Southwest_Pacific": {
+            "boxes": [
+                {"lon_min": 90, "lon_max": 180, "lat_min": -50, "lat_max": 25},
+                {"lon_min": -180, "lon_max": -140, "lat_min": -50, "lat_max": 25},
+            ]
+        },
+        # WMO Region 6 - Europe (includes Middle East countries listed and Greenland)
+        "Europe": {"lon_min": -75, "lon_max": 60, "lat_min": 25, "lat_max": 85},
+        # WMO Region 7 - Antarctica
         "Antarctica": {"lon_min": -180, "lon_max": 180, "lat_min": -90, "lat_max": -60}
     }
 
@@ -306,34 +364,45 @@ def get_nearest_epw_from_climate_onebuilding(longitude: float, latitude: float,
         elif lon > 180:
             lon_adjusted = lon - 360
             
-        # Check if coordinates fall within any region bounds
+        # Helper to test point within a single box
+        def _in_box(bx: Dict[str, float], lon_v: float, lat_v: float) -> bool:
+            return (bx["lon_min"] <= lon_v <= bx["lon_max"] and
+                    bx["lat_min"] <= lat_v <= bx["lat_max"]) 
+
+        # Check if coordinates fall within any region bounds (support multi-box)
         for region_name, bounds in REGION_BOUNDS.items():
-            # Check if point is within region bounds
-            if (bounds["lon_min"] <= lon_adjusted <= bounds["lon_max"] and 
-                bounds["lat_min"] <= lat <= bounds["lat_max"]):
-                matching_regions.append(region_name)
+            if "boxes" in bounds:
+                for bx in bounds["boxes"]:
+                    if _in_box(bx, lon_adjusted, lat):
+                        matching_regions.append(region_name)
+                        break
+            else:
+                if _in_box(bounds, lon_adjusted, lat):
+                    matching_regions.append(region_name)
         
         # If no regions matched, find the closest regions by boundary distance
         if not matching_regions:
             # Calculate "distance" to each region's boundary (simplified metric)
             region_distances = []
             for region_name, bounds in REGION_BOUNDS.items():
-                # Calculate distance to closest edge of region bounds
-                lon_dist = 0
-                if lon_adjusted < bounds["lon_min"]:
-                    lon_dist = bounds["lon_min"] - lon_adjusted
-                elif lon_adjusted > bounds["lon_max"]:
-                    lon_dist = lon_adjusted - bounds["lon_max"]
-                
-                lat_dist = 0
-                if lat < bounds["lat_min"]:
-                    lat_dist = bounds["lat_min"] - lat
-                elif lat > bounds["lat_max"]:
-                    lat_dist = lat - bounds["lat_max"]
-                
-                # Simple Euclidean distance metric (not actual geographic distance)
-                distance = (lon_dist**2 + lat_dist**2)**0.5
-                region_distances.append((region_name, distance))
+                def _box_distance(bx: Dict[str, float]) -> float:
+                    lon_dist = 0
+                    if lon_adjusted < bx["lon_min"]:
+                        lon_dist = bx["lon_min"] - lon_adjusted
+                    elif lon_adjusted > bx["lon_max"]:
+                        lon_dist = lon_adjusted - bx["lon_max"]
+                    lat_dist = 0
+                    if lat < bx["lat_min"]:
+                        lat_dist = bx["lat_min"] - lat
+                    elif lat > bx["lat_max"]:
+                        lat_dist = lat - bx["lat_max"]
+                    return (lon_dist**2 + lat_dist**2)**0.5
+
+                if "boxes" in bounds:
+                    d = min(_box_distance(bx) for bx in bounds["boxes"])
+                else:
+                    d = _box_distance(bounds)
+                region_distances.append((region_name, d))
             
             # Get 3 closest regions to ensure we find stations
             closest_regions = sorted(region_distances, key=lambda x: x[1])[:3]
@@ -511,6 +580,101 @@ def get_nearest_epw_from_climate_onebuilding(longitude: float, latitude: float,
         
         return metadata
 
+    def try_download_station_zip(original_url: str, timeout_s: int = 30) -> Optional[bytes]:
+        """
+        Try downloading station archive; on 404s, attempt smart fallbacks.
+        
+        Fallback strategies:
+        - Country rename: /TUR_Turkey/ -> /TUR_Turkiye/ (per Oct 2024 site update)
+        - TMYx period variants: .2009-2023.zip, .2007-2021.zip, .zip, .2004-2018.zip
+        
+        Args:
+            original_url: URL extracted from KML
+            timeout_s: request timeout seconds
+        Returns:
+            Bytes of the downloaded zip on success, otherwise None
+        """
+        def candidate_urls(url: str) -> List[str]:
+            urls = []
+            urls.append(url)
+            # Country rename variants
+            if "/TUR_Turkey/" in url:
+                urls.append(url.replace("/TUR_Turkey/", "/TUR_Turkiye/"))
+            if "/TUR_Turkiye/" in url:
+                urls.append(url.replace("/TUR_Turkiye/", "/TUR_Turkey/"))
+            # TMYx period variants
+            m = re.search(r"(.*_TMYx)(?:\.(\d{4}-\d{4}))?\.zip$", url)
+            if m:
+                base = m.group(1)
+                suffix = m.group(2)
+                variants = [
+                    f"{base}.2009-2023.zip",
+                    f"{base}.2007-2021.zip",
+                    f"{base}.zip",
+                    f"{base}.2004-2018.zip",
+                ]
+                for v in variants:
+                    if v not in urls:
+                        urls.append(v)
+                # Also apply country rename to each variant
+                extra = []
+                for v in variants:
+                    if "/TUR_Turkey/" in url:
+                        extra.append(v.replace("/TUR_Turkey/", "/TUR_Turkiye/"))
+                    if "/TUR_Turkiye/" in url:
+                        extra.append(v.replace("/TUR_Turkiye/", "/TUR_Turkey/"))
+                for v in extra:
+                    if v not in urls:
+                        urls.append(v)
+            return urls
+
+        tried = set()
+        for u in candidate_urls(original_url):
+            if u in tried:
+                continue
+            tried.add(u)
+            try:
+                resp = requests.get(u, timeout=timeout_s, verify=ssl_verify)
+                resp.raise_for_status()
+                return resp.content
+            except requests.exceptions.SSLError:
+                # Retry with user-controlled insecure SSL
+                if allow_insecure_ssl:
+                    try:
+                        resp = requests.get(u, timeout=timeout_s, verify=False)
+                        resp.raise_for_status()
+                        return resp.content
+                    except requests.exceptions.RequestException:
+                        if allow_http_fallback and u.lower().startswith("https://"):
+                            insecure_url = "http://" + u.split("://", 1)[1]
+                            try:
+                                resp = requests.get(insecure_url, timeout=timeout_s)
+                                resp.raise_for_status()
+                                return resp.content
+                            except requests.exceptions.RequestException:
+                                pass
+                        continue
+                else:
+                    if allow_http_fallback and u.lower().startswith("https://"):
+                        insecure_url = "http://" + u.split("://", 1)[1]
+                        try:
+                            resp = requests.get(insecure_url, timeout=timeout_s)
+                            resp.raise_for_status()
+                            return resp.content
+                        except requests.exceptions.RequestException:
+                            pass
+                    continue
+            except requests.exceptions.HTTPError as he:
+                # Only continue on 404; raise on other HTTP errors
+                if getattr(he.response, "status_code", None) == 404:
+                    continue
+                else:
+                    raise
+            except requests.exceptions.RequestException:
+                # On network errors, try next candidate
+                continue
+        return None
+
     def get_stations_from_kml(kml_url: str) -> List[Dict]:
         """
         Get weather stations from a KML file.
@@ -526,9 +690,32 @@ def get_nearest_epw_from_climate_onebuilding(longitude: float, latitude: float,
             List of dictionaries containing station metadata
         """
         try:
-            # Download KML file with timeout
-            response = requests.get(kml_url, timeout=30)
-            response.raise_for_status()
+            # Download KML file with timeout (secure first)
+            try:
+                response = requests.get(kml_url, timeout=30, verify=ssl_verify)
+                response.raise_for_status()
+            except requests.exceptions.SSLError:
+                if allow_insecure_ssl:
+                    # Retry with certificate verification disabled (last resort)
+                    try:
+                        response = requests.get(kml_url, timeout=30, verify=False)
+                        response.raise_for_status()
+                    except requests.exceptions.RequestException:
+                        # Try HTTP fallback if original was HTTPS and allowed
+                        if allow_http_fallback and kml_url.lower().startswith("https://"):
+                            insecure_url = "http://" + kml_url.split("://", 1)[1]
+                            response = requests.get(insecure_url, timeout=30)
+                            response.raise_for_status()
+                        else:
+                            raise
+                else:
+                    # Try HTTP fallback only if allowed and original was HTTPS
+                    if allow_http_fallback and kml_url.lower().startswith("https://"):
+                        insecure_url = "http://" + kml_url.split("://", 1)[1]
+                        response = requests.get(insecure_url, timeout=30)
+                        response.raise_for_status()
+                    else:
+                        raise
             
             # Try to decode content with multiple encodings
             content = try_decode(response.content)
@@ -584,6 +771,18 @@ def get_nearest_epw_from_climate_onebuilding(longitude: float, latitude: float,
         
         # Determine which regions to scan based on user input or auto-detection
         regions_to_scan = {}
+        def _add_selection(selection_name: str, mapping: Dict[str, str], out: Dict[str, str]):
+            """Expand a region or dataset selection into concrete KML URLs."""
+            if selection_name in REGION_DATASET_GROUPS:
+                for key in REGION_DATASET_GROUPS[selection_name]:
+                    if key in KML_SOURCES:
+                        out[key] = KML_SOURCES[key]
+            elif selection_name in KML_SOURCES:
+                out[selection_name] = KML_SOURCES[selection_name]
+            else:
+                valid = sorted(list(REGION_DATASET_GROUPS.keys()) + list(KML_SOURCES.keys()))
+                raise ValueError(f"Invalid region/dataset: '{selection_name}'. Valid options include: {', '.join(valid)}")
+
         if region is None:
             # Auto-detect regions based on coordinates
             detected_regions = detect_regions(longitude, latitude)
@@ -591,34 +790,32 @@ def get_nearest_epw_from_climate_onebuilding(longitude: float, latitude: float,
             if detected_regions:
                 print(f"Auto-detected regions: {', '.join(detected_regions)}")
                 for r in detected_regions:
-                    regions_to_scan[r] = KML_SOURCES[r]
+                    _add_selection(r, KML_SOURCES, regions_to_scan)
             else:
                 # Fallback to all regions if detection fails
                 print("Could not determine region from coordinates. Scanning all regions.")
-                regions_to_scan = KML_SOURCES
+                regions_to_scan = dict(KML_SOURCES)
         elif isinstance(region, str):
             # Handle string input for region selection
             if region.lower() == "all":
-                regions_to_scan = KML_SOURCES
-            elif region in KML_SOURCES:
-                regions_to_scan[region] = KML_SOURCES[region]
+                regions_to_scan = dict(KML_SOURCES)
             else:
-                valid_regions = ", ".join(KML_SOURCES.keys())
-                raise ValueError(f"Invalid region: '{region}'. Valid regions are: {valid_regions}")
+                _add_selection(region, KML_SOURCES, regions_to_scan)
         else:
             # Handle list input for multiple regions
             for r in region:
-                if r not in KML_SOURCES:
-                    valid_regions = ", ".join(KML_SOURCES.keys())
-                    raise ValueError(f"Invalid region: '{r}'. Valid regions are: {valid_regions}")
-                regions_to_scan[r] = KML_SOURCES[r]
+                _add_selection(r, KML_SOURCES, regions_to_scan)
         
         # Get stations from selected KML sources
         print("Fetching weather station data from Climate.OneBuilding.Org...")
         all_stations = []
         
         # Process each selected region
+        scanned_urls = set()
         for region_name, url in regions_to_scan.items():
+            if url in scanned_urls:
+                continue
+            scanned_urls.add(url)
             print(f"Scanning {region_name}...")
             stations = get_stations_from_kml(url)
             all_stations.extend(stations)
@@ -627,7 +824,23 @@ def get_nearest_epw_from_climate_onebuilding(longitude: float, latitude: float,
         print(f"\nTotal stations found: {len(all_stations)}")
         
         if not all_stations:
-            raise ValueError("No weather stations found")
+            # Fallback: if no stations found, try scanning all available datasets
+            if not (isinstance(region, str) and region.lower() == "all"):
+                print("No stations found from detected/selected regions. Falling back to global scan...")
+                regions_to_scan = dict(KML_SOURCES)
+                all_stations = []
+                scanned_urls = set()
+                for region_name, url in regions_to_scan.items():
+                    if url in scanned_urls:
+                        continue
+                    scanned_urls.add(url)
+                    print(f"Scanning {region_name}...")
+                    stations = get_stations_from_kml(url)
+                    all_stations.extend(stations)
+                    print(f"Found {len(stations)} stations in {region_name}")
+                print(f"\nTotal stations found after global scan: {len(all_stations)}")
+            if not all_stations:
+                raise ValueError("No weather stations found")
             
         # Calculate distances from target coordinates to all stations
         stations_with_distances = [
@@ -654,10 +867,11 @@ def get_nearest_epw_from_climate_onebuilding(longitude: float, latitude: float,
         # Find the nearest weather station
         nearest_station, distance = min(stations_with_distances, key=lambda x: x[1])
         
-        # Download the EPW file from the nearest station
+        # Download the EPW archive from the nearest station with fallbacks
         print(f"\nDownloading EPW file for {nearest_station['name']}...")
-        epw_response = requests.get(nearest_station['url'])
-        epw_response.raise_for_status()
+        archive_bytes = try_download_station_zip(nearest_station['url'], timeout_s=30)
+        if archive_bytes is None:
+            raise ValueError(f"Failed to download EPW archive from station URL and fallbacks: {nearest_station['url']}")
         
         # Create a temporary directory for zip extraction
         temp_dir = Path(output_dir) / "temp"
@@ -666,7 +880,7 @@ def get_nearest_epw_from_climate_onebuilding(longitude: float, latitude: float,
         # Save the downloaded zip file temporarily
         zip_file = temp_dir / "weather_data.zip"
         with open(zip_file, 'wb') as f:
-            f.write(epw_response.content)
+            f.write(archive_bytes)
         
         final_epw = None
         try:
@@ -758,8 +972,15 @@ def read_epw_for_solar_simulation(epw_file_path):
     Raises:
         ValueError: If LOCATION line not found or data parsing fails
     """
+    # Validate input path
+    if epw_file_path is None:
+        raise TypeError("EPW file path is None. Provide a valid path or ensure download succeeded.")
+    epw_path_obj = Path(epw_file_path)
+    if not epw_path_obj.exists() or not epw_path_obj.is_file():
+        raise FileNotFoundError(f"EPW file not found: {epw_file_path}")
+
     # Read the entire EPW file
-    with open(epw_file_path, 'r', encoding='utf-8') as f:
+    with open(epw_path_obj, 'r', encoding='utf-8') as f:
         lines = f.readlines()
 
     # Find the LOCATION line (first line in EPW format)

{voxcity-0.6.18.dist-info → voxcity-0.6.20.dist-info}/METADATA

@@ -1,8 +1,10 @@
-Metadata-Version: 2.3
+Metadata-Version: 2.4
 Name: voxcity
-Version: 0.6.18
+Version: 0.6.20
 Summary: voxcity is an easy and one-stop tool to output 3d city models for microclimate simulation by integrating multiple geospatial open-data
 License: MIT
+License-File: AUTHORS.rst
+License-File: LICENSE
 Author: Kunihiko Fujiwara
 Author-email: fujiwara.kunihiko@takenaka.co.jp
 Maintainer: Kunihiko Fujiwara

{voxcity-0.6.18.dist-info → voxcity-0.6.20.dist-info}/RECORD

@@ -1,6 +1,6 @@
 voxcity/__init__.py,sha256=el9v3gfybHOF_GUYPeSOqN0-vCrTW0eU1mcvi0sEfeU,252
 voxcity/downloader/__init__.py,sha256=o_T_EU7hZLGyXxX9wVWn1x-OAa3ThGYdnpgB1_2v3AE,151
-voxcity/downloader/citygml.py,sha256=vEsMDCjK64UwpCmQi6ELoqC7h5sbIUW8hWAxVf5ViNI,41321
+voxcity/downloader/citygml.py,sha256=I8-wWijqVOA1VeH3nFP9ZlC3l6XvXfli6lB17ZIXHb0,42232
 voxcity/downloader/eubucco.py,sha256=ln1YNaaOgJfxNfCtVbYaMm775-bUvpAA_LDv60_i22w,17875
 voxcity/downloader/gee.py,sha256=nvJvYqcSZyyontRtG2cFeb__ZJfeY4rRN1NBPORxLwQ,23557
 voxcity/downloader/mbfp.py,sha256=UXDVjsO0fnb0fSal9yqrSFEIBThnRmnutnp08kZTmCA,6595
@@ -13,8 +13,8 @@ voxcity/exporter/cityles.py,sha256=Kfl2PAn4WquqCdjOlyPrHysxPLaudh8QfsoC6WAXlvs,1
 voxcity/exporter/envimet.py,sha256=Sh7s1JdQ6SgT_L2Xd_c4gtEGWK2hTS87bccaoIqik-s,31105
 voxcity/exporter/magicavoxel.py,sha256=SfGEgTZRlossKx3Xrv9d3iKSX-HmfQJEL9lZHgWMDX4,12782
 voxcity/exporter/netcdf.py,sha256=48rJ3wDsFhi9ANbElhMjXLxWMJoJzBt1gFbN0ekPp-A,7404
-voxcity/exporter/obj.py,sha256=2MA2GpexMC1_GnMv0u5GVNGO1N9DH8TAtYVcFoWvkbg,50386
-voxcity/generator.py,sha256=4WSjO09f8z3zt0tpKY0fyAfOMym1JT4VH3Tt1lOg2Bk,66900
+voxcity/exporter/obj.py,sha256=7xmVSQ_y-X8QLjNdASDPsaltGvmyW9-yAacocByYKl4,58160
+voxcity/generator.py,sha256=OHSZU4z7Vj6Iqbp1J0xXlFUSPyMsvOgPv3Tren8mEBc,67302
 voxcity/geoprocessor/__init__.py,sha256=WYxcAQrjGucIvGHF0JTC6rONZzL3kCms1S2vpzS6KaU,127
 voxcity/geoprocessor/draw.py,sha256=AZMWq23wxxDJygNloCbVzWAAr1JO7nC94umf9LSxJ5o,49248
 voxcity/geoprocessor/grid.py,sha256=NmlQwl1nJpS7MduVtJeJCG-xBfVIwKTOip7pMm3RhsY,76722
@@ -23,16 +23,16 @@ voxcity/geoprocessor/network.py,sha256=YynqR0nq_NUra_cQ3Z_56KxfRia1b6-hIzGCj3QT-
 voxcity/geoprocessor/polygon.py,sha256=DfzXf6R-qoWXEZv1z1aHCVfr-DCuCFw6lieQT5cNHPA,61188
 voxcity/geoprocessor/utils.py,sha256=s17XpgkLBelmNCk2wcUwTK1tEiFpguWR2BF_n7K17jg,31378
 voxcity/simulator/__init__.py,sha256=APdkcdaovj0v_RPOaA4SBvFUKT2RM7Hxuuz3Sux4gCo,65
-voxcity/simulator/solar.py,sha256=4WBFgMm25-9rZ5bSGBmIpaxq2mma9X46Fom7UvGEnT8,106361
+voxcity/simulator/solar.py,sha256=4D5t2I79vBW1qXd90BZR0tMiA9WOEXWLG5b-d6E2XbQ,107127
 voxcity/simulator/utils.py,sha256=sEYBB2-hLJxTiXQps1_-Fi7t1HN3-1OPOvBCWtgIisA,130
 voxcity/simulator/view.py,sha256=k3FoS6gsibR-eDrTHJivJSQfvN3Tg8R8eSTeMqd9ans,93942
 voxcity/utils/__init__.py,sha256=Q-NYCqYnAAaF80KuNwpqIjbE7Ec3Gr4y_khMLIMhJrg,68
 voxcity/utils/lc.py,sha256=722Gz3lPbgAp0mmTZ-g-QKBbAnbxrcgaYwb1sa7q8Sk,16189
 voxcity/utils/material.py,sha256=H8K8Lq4wBL6dQtgj7esUW2U6wLCOTeOtelkTDJoRgMo,10007
 voxcity/utils/visualization.py,sha256=_c5WnhA0fawkseUviKEIpUUsF-M-OOLOT9FrpgQIh1A,118556
-voxcity/utils/weather.py,sha256=2Jtg-rIVJcsTtiKE-KuDnhIqS1-MSS16_zFRzj6zmu4,36435
-voxcity-0.6.18.dist-info/AUTHORS.rst,sha256=m82vkI5QokEGdcHof2OxK39lf81w1P58kG9ZNNAKS9U,175
-voxcity-0.6.18.dist-info/LICENSE,sha256=s_jE1Df1nTPL4A_5GCGic5Zwex0CVaPKcAmSilxJPPE,1089
-voxcity-0.6.18.dist-info/METADATA,sha256=2KzFc-aRuap89tiZhqAotBF2ACcK86VCJuwg2tUvKbk,26164
-voxcity-0.6.18.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
-voxcity-0.6.18.dist-info/RECORD,,
+voxcity/utils/weather.py,sha256=cb6ZooL42Hc4214OtFiJ78cCgWYM6VE-DU8S3e-urRg,48449
+voxcity-0.6.20.dist-info/licenses/AUTHORS.rst,sha256=m82vkI5QokEGdcHof2OxK39lf81w1P58kG9ZNNAKS9U,175
+voxcity-0.6.20.dist-info/licenses/LICENSE,sha256=s_jE1Df1nTPL4A_5GCGic5Zwex0CVaPKcAmSilxJPPE,1089
+voxcity-0.6.20.dist-info/METADATA,sha256=dRyklxMxGHwtTvE6lT3TfMFIlWBDZ354zt1Dr_Vv7qQ,26212
+voxcity-0.6.20.dist-info/WHEEL,sha256=M5asmiAlL6HEcOq52Yi5mmk9KmTVjY2RDPtO4p9DMrc,88
+voxcity-0.6.20.dist-info/RECORD,,

{voxcity-0.6.18.dist-info → voxcity-0.6.20.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: poetry-core 2.1.3
+Generator: poetry-core 2.2.0
 Root-Is-Purelib: true
 Tag: py3-none-any