smart-spatial-system 0.2.4__tar.gz → 0.2.5__tar.gz

{smart_spatial_system-0.2.4 → smart_spatial_system-0.2.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: smart_spatial_system
-Version: 0.2.4
+Version: 0.2.5
 Summary: Plugin-based GeoAI backend: natural-language questions become QuerySpecs, DAG plans, and map/table/report outputs.
 Author: Araz Shah
 License-Expression: MIT
@@ -49,14 +49,48 @@ Dynamic: license-file
 
 # Smart Spatial System
 
+[![PyPI](https://img.shields.io/pypi/v/smart-spatial-system)](https://pypi.org/project/smart-spatial-system/)
+[![CI](https://github.com/arazshah/smart_spatial_system/actions/workflows/ci.yml/badge.svg)](https://github.com/arazshah/smart_spatial_system/actions/workflows/ci.yml)
+[![License: MIT](https://img.shields.io/badge/license-MIT-blue.svg)](LICENSE)
+[![Python 3.11+](https://img.shields.io/badge/python-3.11%2B-blue)](pyproject.toml)
+
 **Ask a geospatial question in plain language and get map layers, tables, reports and files back.**
 
+**[s3geo.com](https://s3geo.com)** — project site, plugin catalog and case-study index.
+
 Smart Spatial System is a plugin-based GeoAI backend with a React workbench. A question such as *"rank these candidate properties by distance to metro stations, malls and main roads"* is turned into a structured `QuerySpec`, planned as a DAG of spatial operations, executed by plugins against uploaded files or PostGIS, and returned as map-ready outputs with a full execution trace.
 
+![Running the rule-based accessibility example end to end: the planned DAG, then the ranked output](docs/assets/demo.gif)
+
+Real, unedited terminal output from [`examples/accessibility_analysis.py`](examples/accessibility_analysis.py) — no server, no LLM, deterministic by construction. Run it yourself after installing below.
+
 It is the application built on top of [geochat-platform](https://github.com/arazshah/geochat-platform): plugins are written with `geochat_sdk` and executed through `geochat_kernel`.
 
 > **Status:** published and usable, still refactoring internally. Logic is moving out of `orchestrator/` into the layered `smart_spatial_system/` package (see [docs/ARCHITECTURE_TARGET.md](docs/ARCHITECTURE_TARGET.md)); the `orchestrator/*_service.py` modules are compatibility shims during that move. The public surface - the CLI, the HTTP API and the documented entry points below - is stable.
 
+## Why this, not a general-purpose LLM agent with a GIS tool belt
+
+The natural alternative is: give an LLM function-calling access to some GIS
+functions and let it decide what to call. This project deliberately doesn't
+stop there, for reasons that turned out to matter in practice, not just in
+theory - see [`smart-spatial-vienna-accessibility`](https://github.com/arazshah/smart-spatial-vienna-accessibility)'s
+case study and [`CHANGELOG.md`](CHANGELOG.md)'s `0.2.1`-`0.2.4` entries for
+five real bugs this surfaced and fixed:
+
+- **A deterministic path exists alongside the LLM path**, built from the same
+  operation catalog (`OP_CATALOG`). The same analysis can be run by rule and
+  by LLM, so "is the LLM's plan reliable" is a measurable question (Plan
+  Agreement Rate, Rank Stability - see [docs/CASE_STUDIES.md](docs/CASE_STUDIES.md)), not
+  a leap of faith.
+- **Every LLM-generated plan is validated before execution**, not just before
+  syntax errors: missing input roles, an unchained multi-factor scoring step,
+  an asymmetric CRS reprojection, an untyped scoring factor - each is a
+  distinct, previously-silent failure mode this system now catches and raises
+  a specific error for, before spending a single second executing.
+- **Every plugin carries a full execution trace** - which operations ran, in
+  what order, with what parameters - so a wrong answer is debuggable, not a
+  black box.
+
 ---
 
 ## How a query runs
@@ -265,6 +299,15 @@ Full deployment guide - environment variables, authentication, CORS, PostGIS:
 
 Full request and response contracts are in [docs/phase5_query_api_contract.md](docs/phase5_query_api_contract.md) and the other `docs/phase5_*` files.
 
+## Research and case studies
+
+Looking for a study to build on this system, or to see one already done?
+[docs/CASE_STUDIES.md](docs/CASE_STUDIES.md) has a catalog of suggested
+studies (accessibility, risk-aware siting, vegetation change, zoning
+compliance, and a reproducibility-methodology replication) plus what's
+*not* a good fit yet. If you use this software in published work, see
+[CITATION.cff](CITATION.cff).
+
 ## Development
 
 ```bash
@@ -272,6 +315,10 @@ pytest                # full suite
 ruff check .          # lint
 ```
 
+Contributions are welcome - see [CONTRIBUTING.md](CONTRIBUTING.md). Found a
+security issue? See [SECURITY.md](SECURITY.md) rather than opening a public
+issue.
+
 ## Author
 
 [Araz Shahkarami](https://github.com/arazshah) · [araz.me](https://araz.me)

{smart_spatial_system-0.2.4 → smart_spatial_system-0.2.5}/README.md

@@ -1,13 +1,47 @@
 # Smart Spatial System
 
+[![PyPI](https://img.shields.io/pypi/v/smart-spatial-system)](https://pypi.org/project/smart-spatial-system/)
+[![CI](https://github.com/arazshah/smart_spatial_system/actions/workflows/ci.yml/badge.svg)](https://github.com/arazshah/smart_spatial_system/actions/workflows/ci.yml)
+[![License: MIT](https://img.shields.io/badge/license-MIT-blue.svg)](LICENSE)
+[![Python 3.11+](https://img.shields.io/badge/python-3.11%2B-blue)](pyproject.toml)
+
 **Ask a geospatial question in plain language and get map layers, tables, reports and files back.**
 
+**[s3geo.com](https://s3geo.com)** — project site, plugin catalog and case-study index.
+
 Smart Spatial System is a plugin-based GeoAI backend with a React workbench. A question such as *"rank these candidate properties by distance to metro stations, malls and main roads"* is turned into a structured `QuerySpec`, planned as a DAG of spatial operations, executed by plugins against uploaded files or PostGIS, and returned as map-ready outputs with a full execution trace.
 
+![Running the rule-based accessibility example end to end: the planned DAG, then the ranked output](docs/assets/demo.gif)
+
+Real, unedited terminal output from [`examples/accessibility_analysis.py`](examples/accessibility_analysis.py) — no server, no LLM, deterministic by construction. Run it yourself after installing below.
+
 It is the application built on top of [geochat-platform](https://github.com/arazshah/geochat-platform): plugins are written with `geochat_sdk` and executed through `geochat_kernel`.
 
 > **Status:** published and usable, still refactoring internally. Logic is moving out of `orchestrator/` into the layered `smart_spatial_system/` package (see [docs/ARCHITECTURE_TARGET.md](docs/ARCHITECTURE_TARGET.md)); the `orchestrator/*_service.py` modules are compatibility shims during that move. The public surface - the CLI, the HTTP API and the documented entry points below - is stable.
 
+## Why this, not a general-purpose LLM agent with a GIS tool belt
+
+The natural alternative is: give an LLM function-calling access to some GIS
+functions and let it decide what to call. This project deliberately doesn't
+stop there, for reasons that turned out to matter in practice, not just in
+theory - see [`smart-spatial-vienna-accessibility`](https://github.com/arazshah/smart-spatial-vienna-accessibility)'s
+case study and [`CHANGELOG.md`](CHANGELOG.md)'s `0.2.1`-`0.2.4` entries for
+five real bugs this surfaced and fixed:
+
+- **A deterministic path exists alongside the LLM path**, built from the same
+  operation catalog (`OP_CATALOG`). The same analysis can be run by rule and
+  by LLM, so "is the LLM's plan reliable" is a measurable question (Plan
+  Agreement Rate, Rank Stability - see [docs/CASE_STUDIES.md](docs/CASE_STUDIES.md)), not
+  a leap of faith.
+- **Every LLM-generated plan is validated before execution**, not just before
+  syntax errors: missing input roles, an unchained multi-factor scoring step,
+  an asymmetric CRS reprojection, an untyped scoring factor - each is a
+  distinct, previously-silent failure mode this system now catches and raises
+  a specific error for, before spending a single second executing.
+- **Every plugin carries a full execution trace** - which operations ran, in
+  what order, with what parameters - so a wrong answer is debuggable, not a
+  black box.
+
 ---
 
 ## How a query runs
@@ -216,6 +250,15 @@ Full deployment guide - environment variables, authentication, CORS, PostGIS:
 
 Full request and response contracts are in [docs/phase5_query_api_contract.md](docs/phase5_query_api_contract.md) and the other `docs/phase5_*` files.
 
+## Research and case studies
+
+Looking for a study to build on this system, or to see one already done?
+[docs/CASE_STUDIES.md](docs/CASE_STUDIES.md) has a catalog of suggested
+studies (accessibility, risk-aware siting, vegetation change, zoning
+compliance, and a reproducibility-methodology replication) plus what's
+*not* a good fit yet. If you use this software in published work, see
+[CITATION.cff](CITATION.cff).
+
 ## Development
 
 ```bash
@@ -223,6 +266,10 @@ pytest                # full suite
 ruff check .          # lint
 ```
 
+Contributions are welcome - see [CONTRIBUTING.md](CONTRIBUTING.md). Found a
+security issue? See [SECURITY.md](SECURITY.md) rather than opening a public
+issue.
+
 ## Author
 
 [Araz Shahkarami](https://github.com/arazshah) · [araz.me](https://araz.me)

smart_spatial_system-0.2.5/config/plugins/ring_buffer_analysis.example.yaml

@@ -0,0 +1,16 @@
+default_distances: null
+default_units: m
+default_quad_segs: 8
+default_engine: auto
+
+preserve_properties: true
+
+allowed_geometry_types:
+  - Point
+  - MultiPoint
+  - LineString
+  - MultiLineString
+  - Polygon
+  - MultiPolygon
+
+metadata: {}

smart_spatial_system-0.2.5/config/plugins/ring_buffer_analysis.yaml

@@ -0,0 +1,16 @@
+default_distances: null
+default_units: m
+default_quad_segs: 8
+default_engine: auto
+
+preserve_properties: true
+
+allowed_geometry_types:
+  - Point
+  - MultiPoint
+  - LineString
+  - MultiLineString
+  - Polygon
+  - MultiPolygon
+
+metadata: {}

{smart_spatial_system-0.2.4 → smart_spatial_system-0.2.5}/orchestrator/planning/llm_spec_generator.py

@@ -1047,6 +1047,15 @@ Important mappings:
   inputs={{"vector": "<source>", "reference": "<poi>"}}
   params={{"max_distance_m": X, "k": 1, "drop_unmatched": true}}
 
+- "multiple rings/distance bands around a point/line/polygon" (e.g.
+  "200m, 500m and 800m rings around each station", concentric zones, a
+  gradient outward from a feature):
+  use op="ring_buffer" with params={{"distances": [200, 500, 800]}} - do
+  NOT chain op="buffer" multiple times for this. Chaining buffer only ever
+  produces nested full-circle disks (each one containing all the smaller
+  ones), never the annulus/gap BETWEEN two radii, which is what "ring" or
+  "band" means here.
+
 - "inside permitted/buildable polygon":
   op="filter_points_in_polygon"
   inputs={{"vector": "<points>", "polygon": "<polygon_layer>"}}

{smart_spatial_system-0.2.4 → smart_spatial_system-0.2.5}/orchestrator/planning/op_catalog.py

@@ -129,6 +129,17 @@ _BUFFER_PARAM_MAP = {
     "metadata": "metadata",
 }
 
+_RING_BUFFER_PARAM_MAP = {
+    "distances": "distances",
+    "units": "units",
+    "quad_segs": "quad_segs",
+    "engine": "engine",
+    "cap_style": "cap_style",
+    "join_style": "join_style",
+    "mitre_limit": "mitre_limit",
+    "metadata": "metadata",
+}
+
 
 OP_CATALOG: dict[str, OpDescriptor] = {
     # ---------------------------------------------------------------------
@@ -474,6 +485,30 @@ OP_CATALOG: dict[str, OpDescriptor] = {
         ),
     ),
 
+    "ring_buffer": OpDescriptor(
+        op_name="ring_buffer",
+        capability_name="generate_ring_buffers",
+        input_map={
+            "vector": "features",
+        },
+        input_types={
+            "vector": "vector",
+        },
+        param_map=_RING_BUFFER_PARAM_MAP,
+        output_type="vector",
+        notes=(
+            "Create concentric ring (annulus) polygons around input features at "
+            "multiple distances, e.g. params.distances=[200, 500, 800, 1200]. "
+            "Returns the area BETWEEN consecutive radii (a true ring/annulus), "
+            "not cumulative full-circle disks. Use this instead of chaining "
+            "buffer multiple times whenever the user asks for distance bands, "
+            "zonal rings, or a gradient outward from a point/line/polygon - "
+            "chaining buffer only ever produces nested full disks, never the "
+            "gap between two radii. Use metric CRS when distances are in "
+            "meters."
+        ),
+    ),
+
     # ---------------------------------------------------------------------
     # Raster operations
     # ---------------------------------------------------------------------

{smart_spatial_system-0.2.4 → smart_spatial_system-0.2.5}/orchestrator/plugin_modules.py

@@ -30,6 +30,7 @@ DEFAULT_SAFE_PLUGIN_MODULES = [
     "plugins.slope_aspect",
     "plugins.zonal_statistics",
     "plugins.buffer_analysis",
+    "plugins.ring_buffer_analysis",
     "plugins.centroid_extractor",
     "plugins.geometry_validator",
     "plugins.spatial_query_filter",

smart_spatial_system-0.2.5/plugins/ring_buffer_analysis.py

@@ -0,0 +1,409 @@
+"""
+ring_buffer_analysis.py
+
+GeoChat SDK Plugin
+==================
+
+Plugin ID:
+    ring_buffer_analysis
+
+Purpose:
+    Perform vector ring (annulus) buffer analysis on GeoJSON-like features.
+
+Capability:
+    - generate_ring_buffers:
+        Create concentric ring polygons around vector features at multiple
+        distances and return VectorOut. Unlike chaining buffer_vector_features
+        multiple times - which only ever produces nested full-circle disks -
+        this capability returns the actual annulus area BETWEEN consecutive
+        radii, e.g. the ring between 200m and 500m, not the full 500m disk.
+
+Config-aware behavior:
+    Reads config/plugins/ring_buffer_analysis.yaml.
+
+Engines:
+    - shapely (or auto, when shapely is installed):
+        Requires shapely. Builds a real buffer() at each sorted radius and
+        subtracts consecutive buffers to produce true annulus geometry.
+    - python:
+        Not supported. There is no pure-python way to compute the difference
+        between two polygons, so this engine always raises SDKDependencyError.
+
+Important:
+    GeoJSON coordinates are treated as planar coordinates. If coordinates are
+    longitude/latitude degrees, distance is interpreted in coordinate units unless
+    data has already been projected. Metadata stores the requested units, but no
+    CRS transformation is performed in this plugin.
+"""
+
+from __future__ import annotations
+
+from datetime import datetime, timezone
+from typing import Any
+
+from geochat_sdk.decorators import capability
+from geochat_sdk.exceptions import SDKDependencyError
+from geochat_sdk.plugin import auto_collect
+from geochat_sdk.types.vector import VectorOut
+
+from plugins._shared.plugin_config import (
+    load_plugin_config,
+    pick_first,
+    resolve_env_refs,
+)
+from plugins.buffer_analysis import (
+    _build_vector_metadata,
+    _configured_allowed_geometry_types,
+    _extract_features,
+    _get_shapely_tools,
+    _to_float,
+    _to_int,
+    _validate_geometry_type,
+)
+
+PLUGIN_ID = "ring_buffer_analysis"
+
+VALID_ENGINES = {"auto", "shapely", "python"}
+
+_NO_SHAPELY_MESSAGE = "ring buffers require shapely - install shapely or use engine=shapely"
+
+
+def _load_ring_buffer_config() -> dict[str, Any]:
+    """
+    Load config/plugins/ring_buffer_analysis.yaml if available.
+    """
+    config = load_plugin_config(PLUGIN_ID, required=False)
+    if not config:
+        return {}
+    return resolve_env_refs(config)
+
+
+def _utc_now_iso() -> str:
+    """
+    Return current UTC timestamp as ISO string.
+    """
+    return datetime.now(timezone.utc).isoformat()
+
+
+def _validate_engine(engine: str) -> str:
+    """
+    Validate ring buffer engine.
+    """
+    if not isinstance(engine, str) or not engine.strip():
+        raise ValueError("engine must be a non-empty string.")
+
+    engine = engine.strip().lower()
+
+    if engine not in VALID_ENGINES:
+        raise ValueError(f"Unsupported engine '{engine}'. Valid engines: {sorted(VALID_ENGINES)}")
+
+    return engine
+
+
+def _validate_quad_segs(value: Any) -> int:
+    """
+    Validate quad_segs.
+    """
+    quad_segs = _to_int(value, "quad_segs")
+
+    if quad_segs < 1:
+        raise ValueError("quad_segs must be greater than or equal to 1.")
+
+    if quad_segs > 128:
+        raise ValueError("quad_segs is too large. Maximum allowed value is 128.")
+
+    return quad_segs
+
+
+def _validate_distances(distances: Any) -> list[float]:
+    """
+    Validate ring distances: must be a non-empty list of positive numbers,
+    with no duplicates. Automatically sorted ascending.
+    """
+    if not isinstance(distances, (list, tuple)) or len(distances) == 0:
+        raise ValueError("distances must be a non-empty list of positive numbers.")
+
+    values: list[float] = []
+    for item in distances:
+        value = _to_float(item, "distances")
+        if value <= 0:
+            raise ValueError("distances must contain only positive numbers.")
+        values.append(value)
+
+    if len(set(values)) != len(values):
+        raise ValueError("distances must not contain duplicate values.")
+
+    return sorted(values)
+
+
+def _format_ring_label(inner: float, outer: float, units: str) -> str:
+    """
+    Format a ring label, e.g. "0-200m".
+    """
+
+    def _fmt(value: float) -> str:
+        if value == int(value):
+            return str(int(value))
+        return str(value)
+
+    return f"{_fmt(inner)}-{_fmt(outer)}{units}"
+
+
+def _ring_geometry_shapely(
+    geometry: dict[str, Any] | None,
+    inner_distance: float,
+    outer_distance: float,
+    quad_segs: int,
+    cap_style: str,
+    join_style: str,
+    mitre_limit: float,
+) -> dict[str, Any] | None:
+    """
+    Build a single annulus ring geometry between inner_distance and
+    outer_distance using shapely. When inner_distance is 0, the ring is just
+    the outer buffer itself (no subtraction needed).
+    """
+    if geometry is None:
+        return None
+
+    shape, mapping, _ = _get_shapely_tools()
+
+    geom = shape(geometry)
+
+    def _buffer_at(distance: float):
+        try:
+            return geom.buffer(
+                distance,
+                quad_segs=quad_segs,
+                cap_style=cap_style,
+                join_style=join_style,
+                mitre_limit=mitre_limit,
+            )
+        except TypeError:
+            # Compatibility with older shapely versions.
+            return geom.buffer(
+                distance,
+                resolution=quad_segs,
+                cap_style=cap_style,
+                join_style=join_style,
+                mitre_limit=mitre_limit,
+            )
+
+    outer_buffer = _buffer_at(outer_distance)
+
+    if inner_distance <= 0:
+        ring_geom = outer_buffer
+    else:
+        inner_buffer = _buffer_at(inner_distance)
+        ring_geom = outer_buffer.difference(inner_buffer)
+
+    return dict(mapping(ring_geom))
+
+
+@capability(
+    name="generate_ring_buffers",
+    keywords=[
+        "ring buffer",
+        "annulus",
+        "concentric buffer",
+        "multi-ring buffer",
+        "distance band",
+        "buffer zones",
+        "zonal buffer",
+        "حلقه بافر",
+        "بافر هم‌مرکز",
+        "حریم چندگانه",
+        "منطقه فاصله‌ای",
+    ],
+    description=(
+        "Create concentric ring (annulus) polygons around vector features "
+        "at multiple distances - the area between consecutive radii, not "
+        "cumulative full-circle buffers."
+    ),
+    required_inputs=["features", "distances"],
+    optional_inputs=[
+        "units",
+        "engine",
+        "quad_segs",
+        "cap_style",
+        "join_style",
+        "mitre_limit",
+        "metadata",
+    ],
+    output_kind="vector",
+    permissions=[],
+    metadata={
+        "category": "analysis",
+        "data_type": "vector",
+        "operation": "ring_buffer",
+        "returns": "VectorOut",
+        "artifact_kind": "features",
+        "access_scope": "spatial_analysis",
+        "config_aware": True,
+        "routable": True,
+    },
+)
+def generate_ring_buffers(
+    features: Any,
+    distances: list[float] | None = None,
+    units: str | None = None,
+    quad_segs: int | None = None,
+    engine: str | None = None,
+    cap_style: str | None = None,
+    join_style: str | None = None,
+    mitre_limit: float | None = None,
+    metadata: dict[str, Any] | None = None,
+) -> VectorOut:
+    """
+    Create concentric ring (annulus) polygons around vector features.
+
+    Args:
+        features:
+            VectorOut, list[Feature], FeatureCollection dict or single Feature dict.
+        distances:
+            List of positive ring boundary distances. Automatically sorted
+            ascending, so callers do not need to pre-sort. Consecutive values
+            define one ring each: [200, 500, 800, 1200] produces rings
+            0-200, 200-500, 500-800 and 800-1200.
+        units:
+            Distance units label used in metadata and ring_label. If None,
+            config default_units is used.
+        quad_segs:
+            Number of segments per quarter circle.
+        engine:
+            auto | shapely | python. Only shapely (or auto when shapely is
+            installed) can build real annulus geometry - python always
+            raises SDKDependencyError.
+        cap_style:
+            Shapely cap style. Usually: round, flat, square.
+        join_style:
+            Shapely join style. Usually: round, mitre, bevel.
+        mitre_limit:
+            Shapely mitre limit.
+        metadata:
+            Optional metadata to merge into output metadata.
+
+    Returns:
+        VectorOut with one feature per (input feature x ring).
+    """
+    config = _load_ring_buffer_config()
+
+    final_distances = _validate_distances(
+        pick_first(distances, config.get("default_distances"), default=None)
+    )
+
+    final_units = str(pick_first(units, config.get("default_units"), default="m"))
+
+    final_quad_segs = _validate_quad_segs(
+        pick_first(quad_segs, config.get("default_quad_segs"), default=8)
+    )
+
+    final_engine = _validate_engine(
+        str(pick_first(engine, config.get("default_engine"), default="auto"))
+    )
+
+    final_cap_style = str(pick_first(cap_style, config.get("default_cap_style"), default="round"))
+    final_join_style = str(pick_first(join_style, config.get("default_join_style"), default="round"))
+    final_mitre_limit = _to_float(
+        pick_first(mitre_limit, config.get("default_mitre_limit"), default=5.0),
+        "mitre_limit",
+    )
+
+    if final_engine == "python":
+        raise SDKDependencyError(_NO_SHAPELY_MESSAGE)
+
+    try:
+        _get_shapely_tools()
+    except SDKDependencyError as exc:
+        raise SDKDependencyError(_NO_SHAPELY_MESSAGE) from exc
+
+    allowed_geometry_types = _configured_allowed_geometry_types(config)
+    preserve_properties = bool(config.get("preserve_properties", True))
+
+    input_features, source_info = _extract_features(features)
+
+    ring_boundaries = [0.0, *final_distances]
+
+    ring_features: list[dict[str, Any]] = []
+
+    for feature_index, feature in enumerate(input_features):
+        geometry = feature.get("geometry")
+        _validate_geometry_type(geometry, allowed_geometry_types)
+
+        source_properties = dict(feature.get("properties") or {}) if preserve_properties else {}
+
+        for ring_index in range(len(final_distances)):
+            inner = ring_boundaries[ring_index]
+            outer = ring_boundaries[ring_index + 1]
+
+            ring_geometry = _ring_geometry_shapely(
+                geometry=geometry,
+                inner_distance=inner,
+                outer_distance=outer,
+                quad_segs=final_quad_segs,
+                cap_style=final_cap_style,
+                join_style=final_join_style,
+                mitre_limit=final_mitre_limit,
+            )
+
+            properties = dict(source_properties)
+            properties["ring_index"] = ring_index
+            properties["ring_inner"] = inner
+            properties["ring_outer"] = outer
+            properties["ring_label"] = _format_ring_label(inner, outer, final_units)
+            properties["source_feature_index"] = feature_index
+
+            ring_features.append({
+                "type": "Feature",
+                "geometry": ring_geometry,
+                "properties": properties,
+            })
+
+    stats = _build_vector_metadata(ring_features)
+
+    user_metadata = metadata or {}
+    if not isinstance(user_metadata, dict):
+        raise ValueError("metadata must be a dict or None.")
+
+    output_metadata = {
+        "source": "ring_buffer_analysis",
+        "loader": PLUGIN_ID,
+        "operation": "ring_buffer",
+        "distances": final_distances,
+        "units": final_units,
+        "quad_segs": final_quad_segs,
+        "engine_requested": final_engine,
+        "cap_style": final_cap_style,
+        "join_style": final_join_style,
+        "mitre_limit": final_mitre_limit,
+        "input_feature_count": len(input_features),
+        "ring_count": len(final_distances),
+        "output_feature_count": len(ring_features),
+        "created_at": _utc_now_iso(),
+        "note": (
+            "Coordinates are treated as planar coordinates. "
+            "No CRS transformation is performed by this plugin."
+        ),
+        **source_info,
+        **stats,
+        **user_metadata,
+    }
+
+    return VectorOut(
+        features=ring_features,
+        metadata=output_metadata,
+    )
+
+
+PLUGIN = auto_collect(
+    id=PLUGIN_ID,
+    version="1.0.0",
+    name="Ring Buffer Analysis",
+    description=(
+        "Creates concentric ring (annulus) polygons around vector features at "
+        "multiple distances - the area between consecutive radii, computed with "
+        "shapely difference()."
+    ),
+    author="GeoChat Platform Team",
+    permissions=[],
+)

{smart_spatial_system-0.2.4 → smart_spatial_system-0.2.5}/pyproject.toml

@@ -12,7 +12,7 @@ build-backend = "setuptools.build_meta"
 # "Open design questions" for why a namespace migration was deliberately
 # not done here.
 name = "smart_spatial_system"
-version = "0.2.4"
+version = "0.2.5"
 description = "Plugin-based GeoAI backend: natural-language questions become QuerySpecs, DAG plans, and map/table/report outputs."
 readme = "README.md"
 requires-python = ">=3.11"