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

{smart_spatial_system-0.2.2/smart_spatial_system.egg-info → smart_spatial_system-0.2.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: smart_spatial_system
-Version: 0.2.2
+Version: 0.2.4
 Summary: Plugin-based GeoAI backend: natural-language questions become QuerySpecs, DAG plans, and map/table/report outputs.
 Author: Araz Shah
 License-Expression: MIT

{smart_spatial_system-0.2.2 → smart_spatial_system-0.2.4}/config/plugins/distance_calculator.example.yaml

@@ -14,6 +14,7 @@ drop_failed: false
 
 # Optional CRS hint. Does not transform data.
 source_crs: null
+target_crs: null
 warn_if_geographic_crs: true
 
 fields:

{smart_spatial_system-0.2.2 → smart_spatial_system-0.2.4}/config/plugins/distance_calculator.yaml

@@ -5,6 +5,7 @@ preserve_properties: true
 drop_failed: false
 
 source_crs: null
+target_crs: null
 warn_if_geographic_crs: true
 
 fields:

{smart_spatial_system-0.2.2 → smart_spatial_system-0.2.4}/config/plugins/nearest_neighbor.example.yaml

@@ -15,6 +15,7 @@ drop_unmatched: false
 include_target_geometry: false
 
 source_crs: null
+target_crs: null
 warn_if_geographic_crs: true
 
 fields:

{smart_spatial_system-0.2.2 → smart_spatial_system-0.2.4}/config/plugins/nearest_neighbor.yaml

@@ -7,6 +7,7 @@ drop_unmatched: false
 include_target_geometry: false
 
 source_crs: null
+target_crs: null
 warn_if_geographic_crs: true
 
 fields:

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

@@ -1023,6 +1023,25 @@ Pending operations, not executable yet:
 {pending}
 
 Important mappings:
+- CRITICAL - any distance/nearest-neighbor operation (filter_by_distance,
+  spatial_nearest, nearest_neighbor, distance_to) needs BOTH of its vector
+  inputs reprojected with crs_transform first, not just the source/site
+  layer. Distance is computed from raw geometry coordinates with zero CRS
+  awareness - if one layer is reprojected to a metric CRS and the other is
+  left in whatever CRS it was uploaded in (commonly EPSG:4326), the
+  "distance" returned is a number between two points in DIFFERENT CRSs,
+  meaningless but not an error by itself. Reproject EVERY layer that feeds
+  a distance operation to the SAME target CRS, and pass that CRS as both
+  source_crs and target_crs on the distance operation itself - this lets
+  the operation catch a mismatch and raise instead of returning a bogus
+  value:
+    crs_transform(sites) -> sites_metric                 (target_crs="EPSG:31256")
+    crs_transform(metro) -> metro_metric                 (target_crs="EPSG:31256")
+    spatial_nearest(source=sites_metric, target=metro_metric,
+      params={{"source_crs": "EPSG:31256", "target_crs": "EPSG:31256"}})
+  WRONG: spatial_nearest(source=sites_metric, target=metro) - "metro" was
+  never reprojected, so its coordinates are still in the original CRS.
+
 - "nearer than X meters to POI":
   op="filter_by_distance"
   inputs={{"vector": "<source>", "reference": "<poi>"}}
@@ -1052,6 +1071,21 @@ Important mappings:
 - "score/rank":
   use score_features then rank_features.
 
+- CRITICAL - every scoring factor MUST include an explicit "type". There is
+  NO default - a factor with no "type" is rejected, it does not fall back
+  to anything. (An earlier version of this system defaulted a missing
+  "type" to "boolean" silently; for a distance field that meant every
+  score came out 0.0 for every feature, with no error - that default no
+  longer exists.) Valid types: "boolean", "boolean_bonus",
+  "inverse_distance", "risk_level", "inverse_level", "threshold",
+  "condition", "direct", "numeric", "inverse_numeric". A distance field
+  (anything you computed with spatial_nearest/nearest_neighbor/distance_to)
+  needs "type": "inverse_distance" and a numeric "max_distance":
+    {{"name": "near_metro", "field": "distance_to_metro",
+      "type": "inverse_distance", "max_distance": 800, "weight": 1}}
+  WRONG (missing "type" - rejected, not defaulted):
+    {{"field": "distance_to_metro", "weight": -1}}
+
 - CRITICAL - scoring against MORE THAN ONE computed field (e.g. distance to
   several different amenities/references): each computation must be CHAINED
   onto the previous one's output, not all computed separately from the
@@ -1667,12 +1701,12 @@ def _validate_operation_input_roles(spec: QuerySpec) -> None:
 _NEAREST_OPS_WITH_DISTANCE_FIELD = {"spatial_nearest", "nearest_neighbor", "filter_by_distance"}
 
 
-def _extract_scoring_factor_fields(params: dict[str, Any]) -> list[str]:
+def _extract_scoring_factors(params: dict[str, Any]) -> list[dict[str, Any]]:
     """
-    Pull the "field" name out of every factor a score_features op's
-    params declare, across the shapes _normalize_scoring_spec (in
-    plugins/feature_scoring.py) accepts: top-level "factors", or
-    "scoring_spec.factors", or the older nested "scoring_spec.scoring.factors".
+    Pull the raw factor dicts out of a score_features op's params, across
+    the shapes _normalize_scoring_spec (in plugins/feature_scoring.py)
+    accepts: top-level "factors", or "scoring_spec.factors", or the older
+    nested "scoring_spec.scoring.factors".
     """
     factors = params.get("factors")
 
@@ -1688,10 +1722,19 @@ def _extract_scoring_factor_fields(params: dict[str, Any]) -> list[str]:
     if not isinstance(factors, list):
         return []
 
+    return [factor for factor in factors if isinstance(factor, dict)]
+
+
+def _extract_scoring_factor_fields(params: dict[str, Any]) -> list[str]:
+    """
+    Pull the "field" name out of every factor a score_features op's
+    params declare - see _extract_scoring_factors for the shapes this
+    covers.
+    """
     return [
         str(factor["field"])
-        for factor in factors
-        if isinstance(factor, dict) and factor.get("field")
+        for factor in _extract_scoring_factors(params)
+        if factor.get("field")
     ]
 
 
@@ -1751,6 +1794,64 @@ def _ancestor_refs(start_ref: str, ops_by_output: dict[str, OperationSpec]) -> s
     return seen
 
 
+# Kept in sync by hand with plugins/feature_scoring.py's _score_factor -
+# there is no single source of truth to generate this from (unlike
+# OP_CATALOG for operations), so a new factor type added there needs
+# adding here too.
+_VALID_SCORING_FACTOR_TYPES = {
+    "boolean",
+    "boolean_bonus",
+    "inverse_distance",
+    "risk_level",
+    "inverse_level",
+    "threshold",
+    "condition",
+    "direct",
+    "numeric",
+    "inverse_numeric",
+}
+
+
+def _validate_score_features_factor_types(spec: QuerySpec) -> None:
+    """
+    Catch a score_features factor with no "type" before the plan is
+    returned, not when it silently scores everything 0.0.
+
+    plugins/feature_scoring.py's _score_factor has no default for a
+    missing "type" (it raises) - but that only fires at execution time,
+    several steps and possibly minutes of API-billed retries away from
+    the generation step that produced the bad spec. This catches the
+    identical condition immediately, with the same "there is no safe
+    default" reasoning, right where the LLM's output is still available
+    to name in the error.
+    """
+    for op in spec.operations:
+        if op.op != "score_features":
+            continue
+
+        for factor in _extract_scoring_factors(op.params):
+            factor_type = factor.get("type")
+            field_name = factor.get("field") or factor.get("name") or "<unnamed>"
+
+            if not factor_type:
+                raise LLMSpecGenerationError(
+                    f"score_features (output={op.output!r}) has a factor "
+                    f"for field {field_name!r} with no 'type'. There is no "
+                    "safe default - every factor must specify one "
+                    f"explicitly: {sorted(_VALID_SCORING_FACTOR_TYPES)!r}. "
+                    "A distance field almost always wants "
+                    "'inverse_distance' with 'max_distance' set."
+                )
+
+            if factor_type not in _VALID_SCORING_FACTOR_TYPES:
+                raise LLMSpecGenerationError(
+                    f"score_features (output={op.output!r}) has a factor "
+                    f"for field {field_name!r} with unsupported type "
+                    f"{factor_type!r}. Valid types: "
+                    f"{sorted(_VALID_SCORING_FACTOR_TYPES)!r}."
+                )
+
+
 def _validate_score_features_field_chaining(spec: QuerySpec) -> None:
     """
     Catch a score_features op reading from a ref that never accumulated a
@@ -1820,6 +1921,124 @@ def _validate_score_features_field_chaining(spec: QuerySpec) -> None:
                 )
 
 
+# The two vector-bearing input roles for each distance/nearest-neighbor
+# operation, in (this-layer, other-layer) order - used to check that both
+# were reprojected to the same CRS, not just one of them.
+_DISTANCE_OPS_VECTOR_ROLES = {
+    "spatial_nearest": ("source", "target"),
+    "nearest_neighbor": ("source", "target"),
+    "filter_by_distance": ("vector", "reference"),
+    "distance_to": ("vector", "target"),
+}
+
+
+def _crs_transform_target_crs(
+    ref: str, ops_by_output: dict[str, OperationSpec]
+) -> str | None:
+    """
+    The target_crs a ref was reprojected to - either directly (ref is the
+    output of a crs_transform operation), or inherited by walking back
+    through a chain of distance/nearest-neighbor operations on their
+    source side, since those operations don't reproject and so preserve
+    whatever CRS their source input was already in.
+
+    That chain-walk matters for exactly the case
+    accessibility_query_spec.py's own multi-amenity chain produces (and
+    any equivalent LLM-generated chain): only the FIRST spatial_nearest
+    step's source is directly a crs_transform output -
+    "sites_metric" -> spatial_nearest(metro) -> "sites_with_metro" ->
+    spatial_nearest(schools, source="sites_with_metro") -> ... - every
+    later step's source is the previous step's output, not a
+    crs_transform output. An earlier version of this function checked
+    only the literal ref and treated every one of those later steps as
+    "not traceable", which made this validator raise on a plan that was
+    completely correct - caught by testing this exact function against
+    accessibility_query_spec.py's own generated chain, not by inspection.
+
+    Still deliberately narrow on the OTHER side, though: this only walks
+    through the vector-preserving "source" role of a chain of distance
+    ops, never through a join, a filter combining two layers, or any
+    other operation that doesn't obviously preserve a single input's CRS -
+    those remain untraceable (None), which is the conservative direction
+    to be wrong in.
+    """
+    op = ops_by_output.get(ref)
+    if op is None:
+        return None
+
+    if op.op == "crs_transform":
+        target_crs = op.params.get("target_crs")
+        return str(target_crs) if target_crs else None
+
+    roles = _DISTANCE_OPS_VECTOR_ROLES.get(op.op)
+    if roles is not None:
+        this_role, _other_role = roles
+        upstream_ref = op.inputs.get(this_role)
+        if upstream_ref:
+            return _crs_transform_target_crs(str(upstream_ref), ops_by_output)
+
+    return None
+
+
+def _validate_distance_op_crs_symmetry(spec: QuerySpec) -> None:
+    """
+    Catch a distance/nearest-neighbor operation whose two vector inputs
+    were reprojected asymmetrically - one just-reprojected via
+    crs_transform, the other not (or reprojected to a different CRS).
+
+    Distance here is computed from raw geometry coordinates with zero CRS
+    awareness (see calculate_distances/find_nearest_neighbors). Reprojecting
+    only the source/site layer and leaving the target/amenity layer in its
+    original CRS - typically EPSG:4326 from the source upload - produces a
+    "distance" between two points in different CRSs: a large, consistent,
+    completely bogus number, not an error, because nothing before this
+    check ever compared the two layers' actual CRSs.
+
+    Deliberately conservative, same posture as
+    _validate_score_features_field_chaining: only fires when this module
+    can see BOTH refs' immediate CRS provenance disagree (see
+    _crs_transform_target_crs's docstring for exactly what "immediate"
+    means here). A ref this module can't trace to a crs_transform output
+    at all - already in a metric CRS from its source, for instance - is
+    left unvalidated rather than guessed at.
+    """
+    ops_by_output: dict[str, OperationSpec] = {
+        op.output: op for op in spec.operations if op.output
+    }
+
+    for op in spec.operations:
+        roles = _DISTANCE_OPS_VECTOR_ROLES.get(op.op)
+        if roles is None:
+            continue
+
+        this_role, other_role = roles
+        this_ref = op.inputs.get(this_role)
+        other_ref = op.inputs.get(other_role)
+        if not this_ref or not other_ref:
+            continue
+
+        this_crs = _crs_transform_target_crs(str(this_ref), ops_by_output)
+        other_crs = _crs_transform_target_crs(str(other_ref), ops_by_output)
+
+        if this_crs is None and other_crs is None:
+            continue
+
+        if this_crs == other_crs:
+            continue
+
+        raise LLMSpecGenerationError(
+            f"{op.op!r} (output={op.output!r}) reads {this_role}={this_ref!r} "
+            f"(reprojected to {this_crs!r}) and {other_role}={other_ref!r} "
+            f"(reprojected to {other_crs!r}) - these do not match. Every "
+            "layer feeding a distance/nearest-neighbor operation must be "
+            "reprojected with crs_transform to the SAME target CRS before "
+            "the operation runs, or the resulting distance is computed "
+            "between points in two different CRSs and is meaningless. See "
+            "the 'any distance/nearest-neighbor operation needs BOTH of "
+            "its vector inputs reprojected' guidance."
+        )
+
+
 class LLMQuerySpecGenerator:
     def __init__(
         self,
@@ -1868,7 +2087,9 @@ class LLMQuerySpecGenerator:
         spec = query_spec_from_dict(data, raw_query_fallback=raw_query)
         spec = normalize_llm_query_spec_for_planning(spec)
         _validate_operation_input_roles(spec)
+        _validate_score_features_factor_types(spec)
         _validate_score_features_field_chaining(spec)
+        _validate_distance_op_crs_symmetry(spec)
         return spec
 
 

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

@@ -85,6 +85,10 @@ _NEAREST_PARAM_MAP = {
     "precision": "precision",
     "include_target_geometry": "include_target_geometry",
     "source_crs": "source_crs",
+    # Passing both source_crs and target_crs lets find_nearest_neighbors
+    # catch a source/target CRS mismatch and raise instead of silently
+    # computing a meaningless planar distance - see its docstring.
+    "target_crs": "target_crs",
     # Lets a plan chain several nearest-neighbour steps over the same
     # features, each writing its own distance field - see the capability's
     # docstring.
@@ -342,6 +346,10 @@ OP_CATALOG: dict[str, OpDescriptor] = {
             "precision": "precision",
             "drop_failed": "drop_failed",
             "source_crs": "source_crs",
+            # Passing both source_crs and target_crs lets calculate_distances
+            # catch a source/target CRS mismatch and raise instead of
+            # silently computing a meaningless planar distance.
+            "target_crs": "target_crs",
             "metadata": "metadata",
         },
         output_type="vector",

{smart_spatial_system-0.2.2 → smart_spatial_system-0.2.4}/plugins/distance_calculator.py

@@ -713,6 +713,51 @@ def _is_geographic_crs(value: Any) -> bool:
     }
 
 
+def _raise_if_crs_mismatch(
+    *,
+    source_crs: str | None,
+    target_crs: str | None,
+    capability_name: str,
+) -> None:
+    """
+    Raise if source_crs and target_crs are both supplied and don't match.
+
+    Distance/nearest-neighbor calculation here works on raw geometry
+    coordinates with zero CRS awareness - it has no way to notice on its
+    own that source_features and target_features are in different CRSs
+    (e.g. only the source layer was reprojected with crs_transform before
+    this call, or the two calls in a plan used different target CRSs).
+    Left unchecked, that produces a number - not an error - that is
+    physically meaningless: a planar distance between a point in metres
+    and a point in degrees, indistinguishable from a real distance
+    without inspecting the value by hand. This is opt-in (only checked
+    when the caller supplies BOTH hints) rather than required, so callers
+    that don't pass CRS hints at all keep today's behaviour unchanged.
+
+    Comparison is a normalized (stripped, uppercased) string match, not
+    true CRS equivalence - "EPSG:4326" and "CRS:84" describe the same CRS
+    but won't match each other here. That is a deliberately conservative
+    trade-off: false negatives (a real mismatch expressed as equivalent-
+    but-differently-spelled CRSs, missed) are possible, but false
+    positives (correctly matching CRSs rejected) are not, since this
+    module has no CRS-equivalence table to consult.
+    """
+    if not source_crs or not target_crs:
+        return
+
+    if str(source_crs).strip().upper() == str(target_crs).strip().upper():
+        return
+
+    raise ValueError(
+        f"{capability_name}: source_crs={source_crs!r} and "
+        f"target_crs={target_crs!r} do not match. Computing distance "
+        "between features in two different CRSs produces a meaningless "
+        "number, not an error - reproject both source_features and "
+        "target_features to the same CRS with crs_transform first, then "
+        "pass matching source_crs/target_crs here."
+    )
+
+
 def _make_distance_feature(
     *,
     source_feature: dict[str, Any],
@@ -846,6 +891,7 @@ def _build_vector_metadata(features: list[dict[str, Any]]) -> dict[str, Any]:
         "precision",
         "drop_failed",
         "source_crs",
+        "target_crs",
         "metadata",
     ],
     output_kind="vector",
@@ -871,6 +917,7 @@ def calculate_distances(
     precision: int | None = None,
     drop_failed: bool | None = None,
     source_crs: str | None = None,
+    target_crs: str | None = None,
     metadata: dict[str, Any] | None = None,
 ) -> VectorOut:
     """
@@ -890,7 +937,19 @@ def calculate_distances(
         drop_failed:
             If True, failed source/pair results are removed.
         source_crs:
-            CRS hint. Used only for warning metadata.
+            CRS hint for source_features.
+        target_crs:
+            CRS hint for target_features.
+
+            Distance here is computed from raw geometry coordinates with
+            no CRS awareness at all - if source_features and
+            target_features are actually in different CRSs, the result is
+            a number, not an error: meaningless, but indistinguishable
+            from a real distance without inspecting it by hand. Supplying
+            both source_crs and target_crs lets this function catch that
+            case and raise instead of returning it. Neither hint changes
+            how distance is computed; only crs_transform actually
+            reprojects data.
         metadata:
             Optional metadata to merge.
 
@@ -920,8 +979,15 @@ def calculate_distances(
     )
 
     final_source_crs = pick_first(source_crs, config.get("source_crs"), default=None)
+    final_target_crs = pick_first(target_crs, config.get("target_crs"), default=None)
     warn_if_geographic_crs = bool(config.get("warn_if_geographic_crs", True))
 
+    _raise_if_crs_mismatch(
+        source_crs=final_source_crs,
+        target_crs=final_target_crs,
+        capability_name="calculate_distances",
+    )
+
     preserve_properties = bool(config.get("preserve_properties", True))
     fields = _configured_fields(config)
 
@@ -1102,6 +1168,7 @@ def calculate_distances(
         "coordinate_precision": final_precision,
         "drop_failed": final_drop_failed,
         "source_crs": final_source_crs,
+        "target_crs": final_target_crs,
         "planar_only": True,
         "warning": geographic_warning,
         "source_feature_count": len(source_items),

{smart_spatial_system-0.2.2 → smart_spatial_system-0.2.4}/plugins/feature_scoring.py

@@ -228,7 +228,29 @@ def _score_factor(properties: dict[str, Any], factor: dict[str, Any]) -> tuple[f
     if not isinstance(factor, dict):
         raise ValueError("Each scoring factor must be a dict.")
 
-    factor_type = str(factor.get("type") or "boolean")
+    raw_factor_type = factor.get("type")
+    if not raw_factor_type:
+        # A missing "type" used to default to "boolean" silently. For any
+        # factor scoring a non-boolean field - a distance, most commonly -
+        # that produces a wrong, near-constant score (0.0 whenever the
+        # field is falsy, which for a distance means "exactly zero") with
+        # no error at all: this is how a whole batch of LLM-generated
+        # scoring specs that omitted "type" on a distance factor came out
+        # 0.0 for every feature, indistinguishable from a real degenerate
+        # result. "boolean" is a valid, explicit choice (still supported
+        # below) - it must never be the unstated default for a field whose
+        # actual meaning this function has no way to guess.
+        field_name = factor.get("field") or factor.get("name") or "<unnamed>"
+        raise ValueError(
+            f"Scoring factor for field {field_name!r} has no 'type'. There "
+            "is no safe default - specify one explicitly: 'boolean', "
+            "'boolean_bonus', 'inverse_distance', 'risk_level', "
+            "'inverse_level', 'threshold', 'condition', 'direct', "
+            "'numeric', or 'inverse_numeric'. A distance field almost "
+            "always wants 'inverse_distance' with 'max_distance' set."
+        )
+
+    factor_type = str(raw_factor_type)
     name = str(factor.get("name") or factor.get("field") or factor_type)
     field = str(factor.get("field") or "")
     value = _get_property(properties, field) if field else None

{smart_spatial_system-0.2.2 → smart_spatial_system-0.2.4}/plugins/nearest_neighbor.py

@@ -45,6 +45,7 @@ from plugins.distance_calculator import (
     _calculate_distance,
     _geometry_bbox,
     _is_geographic_crs,
+    _raise_if_crs_mismatch,
     _validate_engine,
 )
 
@@ -356,6 +357,7 @@ def _build_vector_metadata(features: list[dict[str, Any]]) -> dict[str, Any]:
         "drop_unmatched",
         "include_target_geometry",
         "source_crs",
+        "target_crs",
         "metadata",
     ],
     output_kind="vector",
@@ -383,6 +385,7 @@ def find_nearest_neighbors(
     drop_unmatched: bool | None = None,
     include_target_geometry: bool | None = None,
     source_crs: str | None = None,
+    target_crs: str | None = None,
     distance_field: str | None = None,
     metadata: dict[str, Any] | None = None,
 ) -> VectorOut:
@@ -407,7 +410,20 @@ def find_nearest_neighbors(
         include_target_geometry:
             If True, target geometry is copied into output properties.
         source_crs:
-            CRS hint. Used only for warning metadata.
+            CRS hint for source_features.
+        target_crs:
+            CRS hint for target_features.
+
+            Distance here is computed from raw geometry coordinates with no
+            CRS awareness at all - if source_features and target_features
+            are actually in different CRSs (e.g. only one of them was
+            reprojected with crs_transform before this call), the result
+            is a number, not an error: meaningless, but indistinguishable
+            from a real distance without inspecting it by hand. Supplying
+            both source_crs and target_crs lets this function catch that
+            case and raise instead of returning it - see the raise below.
+            Neither hint changes how distance is computed; only
+            crs_transform actually reprojects data.
         distance_field:
             Optional output field name for the computed distance,
             overriding the configured default (config/plugins/
@@ -460,8 +476,15 @@ def find_nearest_neighbors(
     )
 
     final_source_crs = pick_first(source_crs, config.get("source_crs"), default=None)
+    final_target_crs = pick_first(target_crs, config.get("target_crs"), default=None)
     warn_if_geographic_crs = bool(config.get("warn_if_geographic_crs", True))
 
+    _raise_if_crs_mismatch(
+        source_crs=final_source_crs,
+        target_crs=final_target_crs,
+        capability_name="find_nearest_neighbors",
+    )
+
     preserve_properties = bool(config.get("preserve_properties", True))
     fields = _configured_fields(config)
 
@@ -594,6 +617,7 @@ def find_nearest_neighbors(
         "drop_unmatched": final_drop_unmatched,
         "include_target_geometry": final_include_target_geometry,
         "source_crs": final_source_crs,
+        "target_crs": final_target_crs,
         "planar_only": True,
         "warning": geographic_warning,
         "source_feature_count": len(source_items),

{smart_spatial_system-0.2.2 → smart_spatial_system-0.2.4}/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.2"
+version = "0.2.4"
 description = "Plugin-based GeoAI backend: natural-language questions become QuerySpecs, DAG plans, and map/table/report outputs."
 readme = "README.md"
 requires-python = ">=3.11"

{smart_spatial_system-0.2.2 → smart_spatial_system-0.2.4}/smart_spatial_system/application/services/query_execution/accessibility_query_spec.py

@@ -191,7 +191,17 @@ def build_accessibility_query_spec(
             OperationSpec(
                 op="nearest_neighbor",
                 inputs={"source": current_sites_ref, "target": amenity_metric_ref},
-                params={"k": 1, "distance_field": amenity.distance_field},
+                # Both sides were just reprojected to target_crs above, so
+                # these are always equal here - passed anyway so
+                # find_nearest_neighbors' own source/target CRS mismatch
+                # check (plugins/distance_calculator.py) protects this
+                # call too, not only hand-written or LLM-generated plans.
+                params={
+                    "k": 1,
+                    "distance_field": amenity.distance_field,
+                    "source_crs": target_crs,
+                    "target_crs": target_crs,
+                },
                 output=enriched_ref,
             )
         )

{smart_spatial_system-0.2.2 → smart_spatial_system-0.2.4/smart_spatial_system.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: smart_spatial_system
-Version: 0.2.2
+Version: 0.2.4
 Summary: Plugin-based GeoAI backend: natural-language questions become QuerySpecs, DAG plans, and map/table/report outputs.
 Author: Araz Shah
 License-Expression: MIT