rsplot 0.3.1.dev3__py3-none-any.whl → 0.3.2.dev4__py3-none-any.whl

rsplot/commands/raster.py

@@ -10,6 +10,9 @@ import typer
 
 from rsplot.commands.common import (
     parse_basemap,
+    resolve_satellite,
+    satellite_errors,
+    satellite_filter_label,
     validate_color_range,
     validate_non_negative,
     validate_positive,
@@ -60,11 +63,13 @@ def parse_raster_dates(
     return dates, window_mode
 
 
+@satellite_errors
 def run_raster(
     *,
     region: str,
     date_arg: str,
     product: str,
+    sensor: str = "tropomi",
     days: int | None,
     n_min: int | None,
     level: str | None,
@@ -83,20 +88,33 @@ def run_raster(
     console: Console,
 ) -> None:
     """Execute raster orchestration without owning the Typer signature."""
-    from rsplot.geo.boundaries import resolve_region
+    from rsplot.geo.boundaries import resolve_regions
     from rsplot.geo.processing import (
         buffered_extent,
+        prepare_display_grid,
         prepare_existing_grid,
         prepare_swath_grid,
     )
     from rsplot.plotting.raster import plot_raster
     from rsplot.plotting.styles import setup_fonts
-    from rsplot.readers import auto_vrange, get_product_info
+    from rsplot.readers import auto_vrange
     from rsplot.results import build_raster_result, emit_result
-    from rsplot.temporal import compute_window_mean
+    from rsplot.temporal import compute_window_mean, read_scan_mean
 
+    cfg = AppConfig.load()
+    prod_info, use_qa = resolve_satellite(product, sensor, qa, cfg, console)
+    sensor = prod_info.sensor
+    scan_mode = sensor == "gems" and len(date_arg) == 12
+    if scan_mode:
+        from rsplot.readers.gems import parse_gems_time
+
+        parse_gems_time(date_arg)
+        if days is not None or n_min is not None:
+            raise ValueError("GEMS 单次扫描不能同时使用 --days 或 --n-min。")
     try:
-        dates, window_mode = parse_raster_dates(date_arg, days)
+        dates, window_mode = parse_raster_dates(
+            date_arg[:8] if scan_mode else date_arg, days
+        )
     except ValueError as e:
         console.print(f"[red]{e}[/red]")
         raise typer.Exit(1) from e
@@ -121,12 +139,18 @@ def run_raster(
             )
             raise typer.Exit(1)
 
-    cfg = AppConfig.load()
     setup_fonts(cfg.font_dir)
 
     console.print(f"[bold]解析区域:[/bold] {region}")
-    info = resolve_region(region, cfg, level_override=level)
+    info = resolve_regions(region, cfg, level_override=level)
     console.print(f"  → [green]{info.name}[/green] (级别: {info.level})")
+    if info.members:
+        console.print(
+            "  → 成员: "
+            + "、".join(
+                member.qualified_name or member.name for member in info.members
+            )
+        )
     console.print(
         f"  → 范围: {info.extent[0]:.2f}°~{info.extent[1]:.2f}°E, "
         f"{info.extent[2]:.2f}°~{info.extent[3]:.2f}°N"
@@ -134,7 +158,6 @@ def run_raster(
 
     params = info.params
     use_dpi = dpi if dpi is not None else cfg.dpi
-    prod_info = get_product_info(product)
     product_defaults = prod_info.defaults_for_level(info.level)
     use_res = (
         res
@@ -144,7 +167,6 @@ def run_raster(
         else params.res
     )
     use_cmap = cmap if cmap is not None else prod_info.cmap
-    use_qa = qa if qa is not None else cfg.qa_threshold
     use_smooth = (
         smooth
         if smooth is not None
@@ -175,10 +197,20 @@ def run_raster(
 
     read_extent = buffered_extent(info.extent, 1.0)
     use_data_dir = (
-        data_dir if data_dir is not None else cfg.get_data_dir(product)
+        data_dir
+        if data_dir is not None
+        else cfg.get_data_dir(prod_info.data_key or product)
     )
     reader = prod_info.reader_cls()
     reader.cloud_fraction_max = cf
+    analysis_res = use_res
+    if sensor == "gems":
+        from rsplot.readers.gems import GEMS_ANALYSIS_RESOLUTION
+
+        analysis_res = GEMS_ANALYSIS_RESOLUTION
+        console.print(
+            f"  → GEMS 分析网格 {analysis_res}°，显示网格 {use_res}°"
+        )
     swath_meta: dict[str, Any]
     window_meta: dict[str, Any] | None = None
     scientific_valid_mask: np.ndarray | None = None
@@ -187,34 +219,61 @@ def run_raster(
         console.print(
             f"\n[bold]读取数据:[/bold] {use_data_dir} (产品: {product})"
         )
-        console.print(f"  日期: {dates[0]}, QA > {use_qa}, CF <= {cf}")
-        swath = reader.read(
-            use_data_dir,
-            dates[0],
-            read_extent,
-            qa_threshold=use_qa,
-        )
         console.print(
-            f"  → [green]{swath.n_pixels}[/green] 有效像元 "
-            f"({swath.n_files} 文件, {swath.n_broken} 损坏)"
+            f"  时间: {date_arg}, {satellite_filter_label(sensor, use_qa, cf)}"
         )
-        console.print(f"\n[bold]网格化:[/bold] {use_res}° 分辨率")
-        prepared = prepare_swath_grid(
-            swath.lon,
-            swath.lat,
-            swath.values,
-            read_extent,
-            use_res,
-            info.geometry,
-        )
-        swath_meta = {
-            "n_pixels": int(swath.n_pixels),
-            "n_files": int(swath.n_files),
-            "n_broken": int(swath.n_broken),
-            "qa_threshold": use_qa,
-            "cloud_fraction_max": cf,
-            "resolution_deg": use_res,
-        }
+        if sensor == "gems":
+            batch = read_scan_mean(
+                reader=reader,
+                data_dir=use_data_dir,
+                request=date_arg,
+                extent=read_extent,
+                res=analysis_res,
+            )
+            prepared = prepare_existing_grid(
+                batch.LON,
+                batch.LAT,
+                batch.grid,
+                info.geometry,
+                fill_gaps=False,
+            )
+            swath_meta = {
+                "n_pixels": batch.n_pixels,
+                "n_files": batch.n_files,
+                "n_broken": batch.n_broken,
+                "resolution_deg": use_res,
+                "cloud_fraction_max": cf,
+                **batch.metadata,
+            }
+            scientific_valid_mask = np.isfinite(prepared.values)
+        else:
+            swath = reader.read(
+                use_data_dir,
+                dates[0],
+                read_extent,
+                qa_threshold=use_qa,
+            )
+            console.print(
+                f"  → [green]{swath.n_pixels}[/green] 有效像元 "
+                f"({swath.n_files} 文件, {swath.n_broken} 损坏)"
+            )
+            console.print(f"\n[bold]网格化:[/bold] {use_res}° 分辨率")
+            prepared = prepare_swath_grid(
+                swath.lon,
+                swath.lat,
+                swath.values,
+                read_extent,
+                use_res,
+                info.geometry,
+            )
+            swath_meta = {
+                "n_pixels": int(swath.n_pixels),
+                "n_files": int(swath.n_files),
+                "n_broken": int(swath.n_broken),
+                "qa_threshold": use_qa,
+                "cloud_fraction_max": cf,
+                "resolution_deg": use_res,
+            }
     else:
         assert use_n_min is not None
         console.print(
@@ -224,13 +283,13 @@ def run_raster(
         console.print(
             f"\n[bold]读取数据:[/bold] {use_data_dir} (产品: {product})"
         )
-        console.print(f"  QA > {use_qa}, CF <= {cf}")
+        console.print(f"  {satellite_filter_label(sensor, use_qa, cf)}")
         window = compute_window_mean(
             reader=reader,
             data_dir=use_data_dir,
             dates=dates,
             extent=read_extent,
-            res=use_res,
+            res=analysis_res,
             qa_threshold=use_qa,
             label=product.upper(),
             console=console,
@@ -287,14 +346,54 @@ def run_raster(
             "coverage_days": coverage_days,
         }
 
-    if not np.isfinite(prepared.values).any():
+        if sensor == "gems":
+            swath_meta.pop("qa_threshold", None)
+            window_meta["aggregation"] = "equal_day_mean_of_equal_scan_means"
+            window_meta["daily"] = window.daily_metadata
+
+    display_source = prepared.unmasked_values
+    statistics_grid = prepared.values.copy() if sensor == "gems" else None
+    display_lon, display_lat = prepared.lon, prepared.lat
+    display_support = None
+    if sensor == "gems":
+        from rsplot.geo.footprints import prepare_footprint_display
+
+        display = prepare_footprint_display(
+            prepared.lon,
+            prepared.lat,
+            display_source,
+            info.geometry,
+            analysis_res=analysis_res,
+            display_res=use_res,
+            smooth_sigma=use_smooth,
+        )
+        display_lon, display_lat = display.lon, display.lat
+        display_grid, display_support = display.values, display.support
+        swath_meta["resolution_deg"] = analysis_res
+        swath_meta["analysis_resolution_deg"] = analysis_res
+        swath_meta["display_resolution_deg"] = use_res
+        swath_meta["display_support"] = "fixed_analysis_valid_cells"
+    else:
+        display_grid = prepare_display_grid(
+            prepared.lon,
+            prepared.lat,
+            display_source,
+            info.geometry,
+            smooth_sigma=use_smooth,
+        )
+
+    if not np.isfinite(display_grid).any():
         console.print(
             "[red]窗口均值全区无有效像元，可能原因：窗口内覆盖不足，"
             "或 --n-min 太严。可放宽 --n-min / 扩大窗口。[/red]"
         )
         raise typer.Exit(1)
 
-    if use_smooth is not None:
+    if (
+        sensor != "gems"
+        and use_smooth is not None
+        and np.isfinite(prepared.values).any()
+    ):
         console.print(f"  → 高斯平滑 sigma={use_smooth}")
         prepared = prepare_existing_grid(
             prepared.lon,
@@ -329,7 +428,12 @@ def run_raster(
         use_vmin = vmin if vmin is not None else prod_info.vmin
         use_vmax = vmax if vmax is not None else prod_info.vmax
     else:
-        auto_min, auto_max = auto_vrange(prepared.values, prod_info)
+        auto_min, auto_max = auto_vrange(
+            prepared.values
+            if np.isfinite(prepared.values).any()
+            else display_grid,
+            prod_info,
+        )
         use_vmin = vmin if vmin is not None else auto_min
         use_vmax = vmax if vmax is not None else auto_max
     try:
@@ -339,11 +443,25 @@ def run_raster(
         raise typer.Exit(1) from e
     console.print(f"  → 色标范围: {use_vmin:.1f} ~ {use_vmax:.1f}")
 
+    if output is None and sensor == "gems":
+        suffix = f"{dates[0]}_{dates[-1]}" if window_mode else date_arg
+        output = f"/tmp/rsplot_gems_{product}_{info.name}_{suffix}.png"
     if output is None:
         if window_mode:
             output = f"/tmp/rsplot_{info.name}_{dates[0]}_{dates[-1]}.png"
         else:
             output = f"/tmp/rsplot_{info.name}_{dates[0]}.png"
+    if title is None and sensor == "gems":
+        period = (
+            f"{dates[0]}~{dates[-1]} mean"
+            if window_mode
+            else (
+                f"{date_arg} CST scan"
+                if scan_mode
+                else f"{date_arg} daily mean (CST)"
+            )
+        )
+        title = f"GEMS {product.upper()} - {info.name} ({period})"
     if title is None and window_mode:
         title = (
             f"TROPOMI {product.upper()} - {info.name} "
@@ -352,9 +470,9 @@ def run_raster(
 
     console.print("\n[bold]绘图中...[/bold]")
     plot_raster(
-        prepared.lon,
-        prepared.lat,
-        prepared.values,
+        display_lon,
+        display_lat,
+        display_grid,
         info,
         dpi=use_dpi,
         cmap=use_cmap,
@@ -365,6 +483,7 @@ def run_raster(
         hcho_cmap_file=cfg.hcho_cmap_file,
         title=title,
         output=output,
+        **({"coverage_geometry": display_support} if sensor == "gems" else {}),
         colorbar_label=prod_info.colorbar_label,
     )
     console.print(f"\n[bold green]✓ 已保存:[/bold green] {output}")
@@ -376,11 +495,16 @@ def run_raster(
         prod_info=prod_info,
         LON=prepared.lon,
         LAT=prepared.lat,
-        grid=prepared.values,
+        grid=statistics_grid
+        if statistics_grid is not None
+        else prepared.values,
         swath_meta=swath_meta,
         vmin=use_vmin,
         vmax=use_vmax,
         output=output,
         window=window_meta,
+        display_grid=display_grid,
+        display_lon=display_lon,
+        display_lat=display_lat,
     )
     emit_result(result, output)

rsplot/commands/recent.py

@@ -7,6 +7,9 @@ from typing import TYPE_CHECKING
 import typer
 
 from rsplot.commands.common import (
+    resolve_satellite,
+    satellite_errors,
+    satellite_filter_label,
     validate_positive,
     validate_unit_interval,
 )
@@ -16,6 +19,7 @@ if TYPE_CHECKING:
     from rich.console import Console
 
 
+@satellite_errors
 def run_recent(
     *,
     region: str,
@@ -23,6 +27,7 @@ def run_recent(
     days: int,
     source: str,
     product: str,
+    sensor: str = "tropomi",
     var: str,
     level: str | None,
     data_dir: str | None,
@@ -35,7 +40,6 @@ def run_recent(
     """Execute recent-day summaries without owning the Typer signature."""
     from rsplot.config import STATION_VAR_META
     from rsplot.geo.boundaries import resolve_region
-    from rsplot.readers import get_product_info
     from rsplot.recent import (
         build_recent_result,
         parse_recent_dates,
@@ -56,6 +60,13 @@ def run_recent(
         raise typer.Exit(1) from e
 
     cfg = AppConfig.load()
+    if use_source == "raster":
+        prod_info, use_qa = resolve_satellite(
+            product, sensor, qa, cfg, console
+        )
+        sensor = prod_info.sensor
+    elif sensor.lower() != "tropomi":
+        raise ValueError("--sensor gems 仅用于 --source raster。")
     console.print(f"[bold]解析区域:[/bold] {region}")
     info = resolve_region(region, cfg, level_override=level)
     console.print(f"  → [green]{info.name}[/green] (级别: {info.level})")
@@ -66,7 +77,8 @@ def run_recent(
     if output is None:
         if use_source == "raster":
             output = (
-                f"/tmp/rsplot_recent_{info.name}_{product}_"
+                f"/tmp/rsplot_recent_{'gems_' if sensor == 'gems' else ''}"
+                f"{info.name}_{product}_"
                 f"{dates[0]}_{dates[-1]}.json"
             )
         else:
@@ -76,7 +88,6 @@ def run_recent(
             )
 
     if use_source == "raster":
-        prod_info = get_product_info(product)
         product_defaults = prod_info.defaults_for_level(info.level)
         use_res = (
             res
@@ -85,7 +96,6 @@ def run_recent(
             if product_defaults.res is not None
             else info.params.res
         )
-        use_qa = qa if qa is not None else cfg.qa_threshold
         try:
             validate_positive(use_res, "--res")
             validate_unit_interval(use_qa, "--qa")
@@ -93,13 +103,19 @@ def run_recent(
         except ValueError as e:
             console.print(f"[red]{e}[/red]")
             raise typer.Exit(1) from e
+        if sensor == "gems":
+            from rsplot.readers.gems import GEMS_ANALYSIS_RESOLUTION
+
+            use_res = GEMS_ANALYSIS_RESOLUTION
         use_data_dir = (
-            data_dir if data_dir is not None else cfg.get_data_dir(product)
+            data_dir
+            if data_dir is not None
+            else cfg.get_data_dir(prod_info.data_key or product)
         )
         console.print(
             f"\n[bold]统计栅格:[/bold] {use_data_dir} "
-            f"(产品: {product}, QA > {use_qa}, "
-            f"CF <= {cf}, res={use_res})"
+            f"(产品: {product}, {satellite_filter_label(sensor, use_qa, cf)}, "
+            f"res={use_res})"
         )
         daily = summarize_recent_raster(
             region=info,
@@ -124,6 +140,8 @@ def run_recent(
                 "resolution_deg": use_res,
             },
             product=product,
+            sensor=sensor,
+            quantity=prod_info.quantity,
             unit=prod_info.colorbar_label,
             output=output,
         )
@@ -132,6 +150,10 @@ def run_recent(
             available = ", ".join(STATION_VAR_META)
             console.print(f"[red]未知变量 '{var}'[/red]。可用: {available}")
             raise typer.Exit(1)
+        if sensor == "gems":
+            from rsplot.readers.gems import GEMS_ANALYSIS_RESOLUTION
+
+            use_res = GEMS_ANALYSIS_RESOLUTION
         use_data_dir = (
             data_dir if data_dir is not None else cfg.get_data_dir("guokong")
         )

rsplot/commands/reconstruct.py

@@ -54,7 +54,11 @@ def run_reconstruct(
 ) -> None:
     """Execute reconstructed-grid orchestration."""
     from rsplot.geo.boundaries import resolve_region
-    from rsplot.geo.processing import buffered_extent, prepare_existing_grid
+    from rsplot.geo.processing import (
+        buffered_extent,
+        prepare_display_grid,
+        prepare_existing_grid,
+    )
     from rsplot.plotting.colormaps import STATION_CONCENTRATION_CMAP
     from rsplot.plotting.raster import plot_raster
     from rsplot.plotting.styles import setup_fonts
@@ -148,10 +152,22 @@ def run_reconstruct(
         info.geometry,
         fill_gaps=False,
     )
-    if not np.isfinite(prepared.values).any():
+    display_source = prepared.unmasked_values
+    display_grid = prepare_display_grid(
+        prepared.lon,
+        prepared.lat,
+        display_source,
+        info.geometry,
+        smooth_sigma=smooth,
+    )
+    if not np.isfinite(display_grid).any():
         console.print("[red]目标区域内没有有效重构网格。[/red]")
         raise typer.Exit(1)
-    if smooth is not None and smooth > 0:
+    if (
+        smooth is not None
+        and smooth > 0
+        and np.isfinite(prepared.values).any()
+    ):
         console.print(f"  → 高斯平滑 sigma={smooth}")
         prepared = prepare_existing_grid(
             prepared.lon,
@@ -167,7 +183,12 @@ def run_reconstruct(
         f"({prepared.n_valid_region}/{prepared.total_region_pixels})"
     )
 
-    auto_min, auto_max = auto_forecast_vrange(prepared.values, var_info)
+    auto_min, auto_max = auto_forecast_vrange(
+        prepared.values
+        if np.isfinite(prepared.values).any()
+        else display_grid,
+        var_info,
+    )
     use_vmin = vmin if vmin is not None else auto_min
     use_vmax = vmax if vmax is not None else auto_max
     try:
@@ -192,7 +213,7 @@ def run_reconstruct(
     plot_raster(
         prepared.lon,
         prepared.lat,
-        prepared.values,
+        display_grid,
         info,
         dpi=use_dpi,
         cmap=use_cmap,
@@ -213,6 +234,7 @@ def run_reconstruct(
         LON=prepared.lon,
         LAT=prepared.lat,
         grid=prepared.values,
+        display_grid=display_grid,
         vmin=use_vmin,
         vmax=use_vmax,
         output=output,

rsplot/config.py

@@ -23,6 +23,9 @@ else:
 # Safe built-in path defaults
 # ---------------------------------------------------------------------------
 KNOWN_DATA_PRODUCTS = (
+    "gems_no2",
+    "gems_hcho",
+    "gems_o3",
     "no2",
     "o3",
     "o3pr",

rsplot/geo/boundaries.py

@@ -58,6 +58,8 @@ class RegionInfo:
     sub_name_field: str = NAME_FIELD
     administrative_level: str | None = None
     subdivision_level: str | None = None
+    qualified_name: str | None = None
+    members: tuple[RegionInfo, ...] = ()
 
 
 def _strip_suffix(name: str) -> str:
@@ -116,7 +118,9 @@ def _load_subdivision_source(
     try:
         source = gpd.read_file(path)
     except Exception as exc:
-        raise ValueError(f"无法读取下级行政区边界文件 '{path}': {exc}") from exc
+        raise ValueError(
+            f"无法读取下级行政区边界文件 '{path}': {exc}"
+        ) from exc
 
     if name_field not in source.columns:
         available = ", ".join(str(column) for column in source.columns)
@@ -137,7 +141,9 @@ def _load_subdivision_source(
     normalized = source[[name_field, "geometry"]].rename(
         columns={name_field: NAME_FIELD}
     )
-    normalized[NAME_FIELD] = normalized[NAME_FIELD].astype("string").str.strip()
+    normalized[NAME_FIELD] = (
+        normalized[NAME_FIELD].astype("string").str.strip()
+    )
     normalized = normalized[
         normalized[NAME_FIELD].notna()
         & normalized[NAME_FIELD].ne("")
@@ -280,6 +286,7 @@ def _resolve_qualified_county(
         main_gdf=county_match,
         sub_gdf=None,
         administrative_level=administrative_level,
+        qualified_name=f"{canonical_city_name}/{county_match.iloc[0][NAME_FIELD]}",
     )
 
 
@@ -451,6 +458,7 @@ def _build_info(
     detail_gdf: gpd.GeoDataFrame | None = None,
     administrative_level: str | None = None,
     subdivision_level: str | None = None,
+    qualified_name: str | None = None,
 ) -> RegionInfo:
     bounds = geometry.bounds  # (minx, miny, maxx, maxy)
     params = LEVEL_DEFAULTS[level]
@@ -471,4 +479,99 @@ def _build_info(
         detail_boundary_gdf=detail_gdf,
         administrative_level=administrative_level,
         subdivision_level=subdivision_level,
+        qualified_name=qualified_name,
+    )
+
+
+def resolve_regions(
+    expression: str,
+    cfg: AppConfig,
+    level_override: str | None = None,
+) -> RegionInfo:
+    """Resolve a comma-separated selection without changing single-region APIs."""
+    if "," not in expression and "，" not in expression:
+        return resolve_region(expression, cfg, level_override)
+    names = [
+        part.replace("\r", "").replace("\n", "").strip()
+        for part in re.split("[,，]", expression)
+    ]
+    if any(not name for name in names):
+        raise ValueError("多区域列表包含空项，请检查连续逗号或首尾逗号。")
+    members = []
+    seen = set()
+    for index, name in enumerate(names, 1):
+        try:
+            member = resolve_region(name, cfg, level_override)
+        except ValueError as error:
+            raise ValueError(
+                f"第 {index} 个区域 '{name}' 无法解析：{error}"
+            ) from error
+        key = (member.level, member.qualified_name or member.name)
+        if key not in seen:
+            members.append(member)
+            seen.add(key)
+
+    levels = ("country", "key_region", "province", "city", "county")
+    level = min((member.level for member in members), key=levels.index)
+    geometry = unary_union([member.geometry for member in members])
+    crs = next(
+        (
+            m.main_boundary_gdf.crs
+            for m in members
+            if m.main_boundary_gdf is not None
+            and m.main_boundary_gdf.crs is not None
+        ),
+        "EPSG:4326",
     )
+    main = gpd.GeoDataFrame(
+        {NAME_FIELD: [m.qualified_name or m.name for m in members]},
+        geometry=[m.geometry for m in members],
+        crs=crs,
+    )
+    sub = _merge_member_layers(members, "sub_boundary_gdf", crs)
+    detail = _merge_member_layers(members, "detail_boundary_gdf", crs)
+    if detail is not None and sub is not None:
+        sub_keys = {g.normalize().wkb for g in sub.geometry}
+        detail = detail[
+            ~detail.geometry.map(lambda g: g.normalize().wkb in sub_keys)
+        ].copy()
+    info = _build_info(
+        name=f"联合区域（{len(members)}个）",
+        level=level,
+        geometry=geometry,
+        main_gdf=main,
+        sub_gdf=sub,
+        detail_gdf=detail,
+    )
+    info.members = tuple(members)
+    return info
+
+
+def _merge_member_layers(
+    members: list[RegionInfo],
+    attribute: str,
+    crs: object,
+) -> gpd.GeoDataFrame | None:
+    """Keep only each member's own subdivisions and deduplicate shared features."""
+    rows = []
+    seen = set()
+    for member in members:
+        frame = getattr(member, attribute)
+        if frame is None or len(frame) == 0:
+            continue
+        if frame.crs is not None and frame.crs != crs:
+            frame = frame.to_crs(crs)
+        for _, row in frame.iterrows():
+            geometry = row.geometry.intersection(member.geometry)
+            if geometry.is_empty or geometry.area == 0:
+                continue
+            key = geometry.normalize().wkb
+            if key in seen:
+                continue
+            seen.add(key)
+            rows.append(
+                {NAME_FIELD: row[member.sub_name_field], "geometry": geometry}
+            )
+    if not rows:
+        return None
+    return gpd.GeoDataFrame(rows, geometry="geometry", crs=crs)