Format Python code with Black

Fix CI formatting check failures by running Black formatter on:
- pycancensus/regions.py
- pycancensus/datasets.py
- pycancensus/intersect_geometry.py
- pycancensus/vectors.py
- pycancensus/core.py

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <noreply@anthropic.com>

Author: dshkol

pycancensus/core.py

@@ -314,52 +314,46 @@ def _extract_vector_metadata(df, vectors, labels):
     """Extract vector metadata from column names and store as attribute."""
     if not vectors:
         return df
-    
+
     # Find vector columns - they have format "v_DATASET_NUM: Description"
     vector_cols = [col for col in df.columns if col.startswith("v_")]
-    
+
     if not vector_cols:
         return df
-    
+
     # Build metadata DataFrame
     metadata_rows = []
     rename_dict = {}
-    
+
     for col in vector_cols:
         if ": " in col:
             # Column has format "v_CA21_1: Total - Population"
             parts = col.split(": ", 1)
             vector_code = parts[0]
             detail = parts[1] if len(parts) > 1 else ""
-            
-            metadata_rows.append({
-                "Vector": vector_code,
-                "Detail": detail
-            })
-            
+
+            metadata_rows.append({"Vector": vector_code, "Detail": detail})
+
             # For short labels, rename column to just the vector code
             if labels == "short":
                 rename_dict[col] = vector_code
         else:
             # Column is already just the vector code
             vector_code = col
             # Try to get detail from vector list if available
-            metadata_rows.append({
-                "Vector": vector_code,
-                "Detail": ""
-            })
-    
+            metadata_rows.append({"Vector": vector_code, "Detail": ""})
+
     # Create metadata DataFrame
     if metadata_rows:
         metadata_df = pd.DataFrame(metadata_rows)
-        
+
         # Rename columns if using short labels
         if rename_dict:
             df = df.rename(columns=rename_dict)
-        
+
         # Store metadata as attribute (always store, but mainly useful with short labels)
-        df.attrs['census_vectors'] = metadata_df
-    
+        df.attrs["census_vectors"] = metadata_df
+
     return df
 
 

pycancensus/datasets.py

@@ -139,20 +139,20 @@ def get_dataset_attribution(dataset: str) -> str:
 def dataset_attribution(datasets):
     """
     Get combined attribution text for multiple datasets.
-    
+
     This function combines attribution text for multiple datasets, merging
     similar attributions that only differ by year.
-    
+
     Parameters
     ----------
     datasets : list of str
         List of dataset identifiers (e.g., ['CA06', 'CA16']).
-        
+
     Returns
     -------
     list of str
         List of attribution strings, with similar attributions merged.
-        
+
     Examples
     --------
     >>> import pycancensus as pc
@@ -162,32 +162,32 @@ def dataset_attribution(datasets):
     ...     print(attr)
     """
     import re
-    
+
     # Get all datasets info
     datasets_df = list_census_datasets(quiet=True)
-    
+
     # Filter for requested datasets
     datasets = [d.upper() for d in datasets]
     dataset_rows = datasets_df[datasets_df["dataset"].isin(datasets)]
-    
+
     if len(dataset_rows) == 0:
         raise ValueError(f"No valid datasets found in {datasets}")
-    
+
     # Get attribution texts
     attributions = dataset_rows["attribution"].tolist()
-    
+
     # Group similar attributions that differ only by year
     # Create a mapping of pattern to actual attributions
     pattern_map = {}
-    
+
     for attr in attributions:
         # Replace 4-digit years with placeholder to create pattern
-        pattern = re.sub(r'\d{4}', '{{YEAR}}', attr)
-        
+        pattern = re.sub(r"\d{4}", "{{YEAR}}", attr)
+
         if pattern not in pattern_map:
             pattern_map[pattern] = []
         pattern_map[pattern].append(attr)
-    
+
     # For each pattern, merge the years
     result = []
     for pattern, attr_list in pattern_map.items():
@@ -199,19 +199,19 @@ def dataset_attribution(datasets):
             # Extract all years from the attributions
             all_years = []
             for attr in attr_list:
-                years = re.findall(r'\d{4}', attr)
+                years = re.findall(r"\d{4}", attr)
                 all_years.extend(years)
-            
+
             # Remove duplicates and sort
             unique_years = sorted(list(set(all_years)))
-            
+
             # Replace {{YEAR}} placeholder with merged years
             if len(unique_years) > 0:
-                year_string = ', '.join(unique_years)
-                merged = pattern.replace('{{YEAR}}', year_string)
+                year_string = ", ".join(unique_years)
+                merged = pattern.replace("{{YEAR}}", year_string)
                 result.append(merged)
             else:
                 # No years found, just use first attribution
                 result.append(attr_list[0])
-    
+
     return result

pycancensus/intersect_geometry.py

@@ -27,12 +27,12 @@ def get_intersecting_geometries(
 ) -> Union[List[str], Dict[str, List[str]]]:
     """
     Get identifiers for census regions intersecting a geometry.
-    
+
     This function returns a list of regions that intersect a given geometry input.
     This list of regions can be used directly to query census when one is interested
     in census data for a particular geographic region that does not coincide with
     defined census geometries.
-    
+
     Parameters
     ----------
     dataset : str
@@ -53,27 +53,27 @@ def get_intersecting_geometries(
     api_key : str, optional
         API key for CensusMapper API. If None, uses environment variable
         or previously set key.
-        
+
     Returns
     -------
     List[str] or Dict[str, List[str]]
         If simplified=True, returns a list of region identifiers.
         If simplified=False, returns a dictionary with level as key and
         list of region IDs as value, suitable for use with get_census().
-        
+
     Examples
     --------
     >>> import pycancensus as pc
     >>> from shapely.geometry import Point
-    >>> 
+    >>>
     >>> # Example using a Point from lat/lon coordinates
     >>> point_geo = Point(-123.25149, 49.27026)
     >>> regions = pc.get_intersecting_geometries(
-    ...     dataset='CA21', 
-    ...     level='CT', 
+    ...     dataset='CA21',
+    ...     level='CT',
     ...     geometry=point_geo
     ... )
-    >>> 
+    >>>
     >>> # Use regions to get census data
     >>> census_data = pc.get_census(
     ...     dataset='CA21',
@@ -84,43 +84,43 @@ def get_intersecting_geometries(
     """
     # Validate inputs
     validate_dataset(dataset)
-    
+
     if api_key is None:
         api_key = get_api_key()
         if api_key is None:
             raise ValueError(
                 "API key required. Set with set_api_key() or CANCENSUS_API_KEY "
                 "environment variable."
             )
-    
+
     # Process geometry input
     processed_geometry = _process_geometry_input(geometry)
-    
+
     # Ensure geometry is in WGS84 (EPSG:4326)
     if processed_geometry.crs is None:
         warnings.warn("No CRS specified for geometry, assuming WGS84 (EPSG:4326)")
-        processed_geometry = processed_geometry.set_crs('EPSG:4326')
+        processed_geometry = processed_geometry.set_crs("EPSG:4326")
     elif processed_geometry.crs.to_epsg() != 4326:
-        processed_geometry = processed_geometry.to_crs('EPSG:4326')
-    
+        processed_geometry = processed_geometry.to_crs("EPSG:4326")
+
     # Union multiple geometries if needed
     if len(processed_geometry) > 1:
         geometry_union = unary_union(processed_geometry.geometry)
-        processed_geometry = gpd.GeoSeries([geometry_union], crs='EPSG:4326')
-    
+        processed_geometry = gpd.GeoSeries([geometry_union], crs="EPSG:4326")
+
     # Convert to GeoJSON
     geojson_str = processed_geometry.to_json()
-    
+
     # Calculate area in square meters (approximate for WGS84)
     # Using area in degrees^2 * conversion factor for rough area estimate
     area = processed_geometry.area.iloc[0]
     # Convert from square degrees to approximate square meters at equator
-    area_m2 = area * (111320 ** 2)  # Rough conversion
-    
+    area_m2 = area * (111320**2)  # Rough conversion
+
     # Create cache key
     param_string = f"dataset={dataset}&level={level}&geometry={geojson_str}"
     cache_key = f"intersect_{hashlib.md5(param_string.encode()).hexdigest()}"
-    
+
     # Check cache first
     if use_cache:
         cached_data = get_cached_data(cache_key)
@@ -137,7 +137,7 @@ def get_intersecting_geometries(
         result = _query_intersecting_geometries_api(
             dataset, level, geojson_str, area_m2, api_key, quiet
         )
-    
+
     # Format output based on simplified parameter
     if simplified:
         # Return simple list of region IDs
@@ -162,7 +162,7 @@ def _process_geometry_input(geometry) -> gpd.GeoSeries:
         return geometry.geometry
     elif isinstance(geometry, gpd.GeoSeries):
         return geometry
-    elif hasattr(geometry, '__geo_interface__'):
+    elif hasattr(geometry, "__geo_interface__"):
         # Shapely geometry or similar
         return gpd.GeoSeries([geometry])
     else:
@@ -173,12 +173,11 @@ def _process_geometry_input(geometry) -> gpd.GeoSeries:
 
 
 def _query_intersecting_geometries_api(
-    dataset: str, level: str, geojson_str: str, area: float, 
-    api_key: str, quiet: bool
+    dataset: str, level: str, geojson_str: str, area: float, api_key: str, quiet: bool
 ) -> Any:
     """Query the CensusMapper API for intersecting geometries."""
     base_url = "https://censusmapper.ca/api/v1/"
-    
+
     # Prepare request data
     request_data = {
         "dataset": dataset,
@@ -187,10 +186,10 @@ def _query_intersecting_geometries_api(
         "area": area,
         "api_key": api_key,
     }
-    
+
     if not quiet:
         print("Querying CensusMapper API for intersecting geometries...")
-    
+
     try:
         response = requests.post(
             f"{base_url}intersecting_geographies",
@@ -199,19 +198,21 @@ def _query_intersecting_geometries_api(
             timeout=60,
         )
         response.raise_for_status()
-        
+
         result = response.json()
-        
+
         if not quiet:
             if isinstance(result, list):
                 print(f"✅ Found {len(result)} intersecting regions")
             elif isinstance(result, dict):
-                total = sum(len(v) if isinstance(v, list) else 1 for v in result.values())
+                total = sum(
+                    len(v) if isinstance(v, list) else 1 for v in result.values()
+                )
                 print(f"✅ Found {total} intersecting regions")
-        
+
         return result
-        
+
     except requests.exceptions.RequestException as e:
         raise RuntimeError(f"API request failed: {e}")
     except Exception as e:
-        raise RuntimeError(f"Failed to process API response: {e}")
+        raise RuntimeError(f"Failed to process API response: {e}")

pycancensus/regions.py

@@ -82,16 +82,17 @@ def list_census_regions(
 
         # Parse CSV response
         import io
+
         df = pd.read_csv(io.StringIO(response.text))
 
         # Map column names to match expected output format
         # CSV columns: name, geo_uid, type, population, flag, CMA_UID, CD_UID, PR_UID
         # Expected: region, name, level, pop, municipal_status, CMA_UID, CD_UID, PR_UID
         column_mapping = {
-            'geo_uid': 'region',
-            'type': 'level',
-            'population': 'pop',
-            'flag': 'municipal_status',
+            "geo_uid": "region",
+            "type": "level",
+            "population": "pop",
+            "flag": "municipal_status",
         }
 
         df = df.rename(columns=column_mapping)