geochat-sdk 1.0.0__tar.gz

geochat_sdk-1.0.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Araz Shah
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

geochat_sdk-1.0.0/PKG-INFO

@@ -0,0 +1,28 @@
+Metadata-Version: 2.4
+Name: geochat-sdk
+Version: 1.0.0
+Summary: Lightweight SDK for building GeoChat Spatial AI plugins
+Author: Araz Shah
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/arazshah/geochat-platform
+Project-URL: Repository, https://github.com/arazshah/geochat-platform
+Project-URL: Issues, https://github.com/arazshah/geochat-platform/issues
+Keywords: geospatial,gis,plugins,spatial-analysis,geoai
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Scientific/Engineering :: GIS
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: pydantic>=2.0.0
+Requires-Dist: geochat-kernel>=1.0.0
+Dynamic: license-file
+
+# GeoChat SDK
+This SDK provides decorators and domain models to build trusted spatial plugins for the GeoChat Core Engine.

geochat_sdk-1.0.0/README.md

@@ -0,0 +1,2 @@
+# GeoChat SDK
+This SDK provides decorators and domain models to build trusted spatial plugins for the GeoChat Core Engine.

geochat_sdk-1.0.0/geochat_sdk/__init__.py

@@ -0,0 +1,33 @@
+"""
+GeoChat SDK public API.
+
+This __init__.py is aligned with the current SDK implementation:
+- capability is defined in geochat_sdk.decorators
+- auto_collect and SDKPlugin are defined in geochat_sdk.plugin
+- Raster/Vector helper types are defined in geochat_sdk.types
+"""
+
+from __future__ import annotations
+
+from geochat_sdk.decorators import capability
+from geochat_sdk.plugin import auto_collect, SDKPlugin
+from geochat_sdk.types.raster import RasterIn, RasterOut
+from geochat_sdk.types.vector import VectorIn, VectorOut
+from geochat_sdk.exceptions import SDKError, SDKDependencyError, SDKValidationError
+
+__all__ = [
+    "capability",
+    "auto_collect",
+    "SDKPlugin",
+    "RasterIn",
+    "RasterOut",
+    "VectorIn",
+    "VectorOut",
+    "SDKError",
+    "SDKDependencyError",
+    "SDKValidationError",
+]
+
+# Must match [project].version in ../pyproject.toml - that file is the
+# source of truth for what PyPI publishes.
+__version__ = "1.0.0"

geochat_sdk-1.0.0/geochat_sdk/decorators.py

@@ -0,0 +1,89 @@
+# geochat_sdk/decorators.py
+from __future__ import annotations
+
+from typing import Any, Callable
+
+from geochat_kernel.models.capability import CapabilityDescriptor
+
+
+class CapabilityRegistration:
+    """
+    Internal registry descriptor for a decorated capability.
+    """
+
+    def __init__(
+        self,
+        func: Callable,
+        name: str,
+        keywords: list[str] | None = None,
+        description: str | None = None,
+        required_inputs: list[str] | None = None,
+        optional_inputs: list[str] | None = None,
+        output_kind: str | None = None,
+        requires_permissions: list[str] | None = None,
+        metadata: dict[str, Any] | None = None,
+    ) -> None:
+        self.func = func
+        self.name = name
+        self.keywords = keywords or []
+        self.description = description or func.__doc__ or f"Geospatial capability: {name}"
+        self.required_inputs = required_inputs or []
+        self.optional_inputs = optional_inputs or []
+        self.output_kind = output_kind or "payload"
+        self.requires_permissions = requires_permissions or []
+        self.metadata = metadata or {}
+
+    def build_descriptor(self, plugin_id: str) -> CapabilityDescriptor:
+        return CapabilityDescriptor(
+            name=self.name,
+            kind="capability",
+            plugin_id=plugin_id,
+            component_name=f"handler_{plugin_id}_{self.func.__name__}",
+            description=self.description,
+            keywords=self.keywords,
+            required_inputs=self.required_inputs,
+            optional_inputs=self.optional_inputs,
+            output_kind=self.output_kind,
+            requires_permissions=self.requires_permissions,
+            metadata={**self.metadata, "routable": True},
+        )
+
+
+_PENDING_CAPABILITIES: list[CapabilityRegistration] = []
+
+
+def capability(
+    name: str,
+    *,
+    keywords: list[str] | None = None,
+    description: str | None = None,
+    required_inputs: list[str] | None = None,
+    optional_inputs: list[str] | None = None,
+    output_kind: str | None = None,
+    permissions: list[Any] | None = None,
+    metadata: dict[str, Any] | None = None,
+) -> Callable[[Callable], Callable]:
+    """
+    Declare a function as a routable geospatial capability.
+    """
+    def decorator(func: Callable) -> Callable:
+        perm_list = []
+        if permissions:
+            for p in permissions:
+                perm_list.append(p.value if hasattr(p, "value") else str(p))
+
+        reg = CapabilityRegistration(
+            func=func,
+            name=name,
+            keywords=keywords,
+            description=description,
+            required_inputs=required_inputs,
+            optional_inputs=optional_inputs,
+            output_kind=output_kind,
+            requires_permissions=perm_list,
+            metadata=metadata,
+        )
+        _PENDING_CAPABILITIES.append(reg)
+        setattr(func, "__geochat_capability__", reg)
+        return func
+    return decorator

geochat_sdk-1.0.0/geochat_sdk/exceptions.py

@@ -0,0 +1,13 @@
+# geochat_sdk/exceptions.py
+from __future__ import annotations
+
+class SDKError(Exception):
+    """Base exception for all GeoChat SDK errors."""
+
+
+class SDKDependencyError(SDKError):
+    """Raised when a geospatial library (e.g., rasterio, geopandas) is required but missing."""
+
+
+class SDKValidationError(SDKError):
+    """Raised when a capability function signature, type, or mapping is invalid."""

geochat_sdk-1.0.0/geochat_sdk/plugin.py

@@ -0,0 +1,351 @@
+# geochat_sdk/plugin.py
+from __future__ import annotations
+
+import inspect
+import typing
+from typing import Any, Callable, get_type_hints
+
+from geochat_kernel.contracts.planner import BasePlanner
+from geochat_kernel.contracts.plugin import BasePlugin
+from geochat_kernel.contracts.result_fusion import BaseResultFusion
+from geochat_kernel.contracts.step_handler import BaseStepHandler
+from geochat_kernel.models.execution_artifact import ExecutionArtifact
+from geochat_kernel.models.geo_response import GeoResponse
+from geochat_kernel.models.manifest import PluginManifest
+from geochat_kernel.models.query_ir import QueryIR
+from geochat_kernel.models.query_plan import PlanStep, QueryPlan
+from geochat_kernel.runtime.execution_context import ExecutionContext
+
+from geochat_sdk.decorators import CapabilityRegistration, _PENDING_CAPABILITIES
+from geochat_sdk.types.raster import RasterIn, RasterOut
+from geochat_sdk.types.vector import VectorIn, VectorOut
+
+
+class SDKStepHandler(BaseStepHandler):
+    """
+    Dynamic Step Handler generated by the SDK.
+    Performs automatic type coercion for arguments and return values.
+    """
+
+    def __init__(self, plugin_id: str, reg: CapabilityRegistration) -> None:
+        self._plugin_id = plugin_id
+        self._reg = reg
+        self._step_type = f"sdk.{plugin_id}.{reg.name}"
+
+    @property
+    def name(self) -> str:
+        return f"handler_{self._plugin_id}_{self._reg.func.__name__}"
+
+    @property
+    def handled_types(self) -> list[str]:
+        return [self._step_type]
+
+    @property
+    def priority(self) -> int:
+        return 100
+
+    async def handle(
+        self,
+        step: PlanStep,
+        inputs: dict[str, ExecutionArtifact],
+        context: ExecutionContext,
+    ) -> ExecutionArtifact:
+        sig = inspect.signature(self._reg.func)
+        kwargs: dict[str, Any] = {}
+
+        # ── کلید اصلاح: resolve کردن annotation‌های رشته‌ای به نوع واقعی ──
+        try:
+            resolved_hints = get_type_hints(self._reg.func)
+        except Exception:
+            # اگر resolve ناموفق بود، از annotation خام استفاده می‌کنیم
+            resolved_hints = {
+                p: param.annotation
+                for p, param in sig.parameters.items()
+                if param.annotation is not inspect.Parameter.empty
+            }
+
+        for param_name, param in sig.parameters.items():
+            # annotation واقعی (نه رشته) را از resolved_hints می‌گیریم
+            annotation = resolved_hints.get(param_name, param.annotation)
+
+            # 1. Map context
+            if annotation is ExecutionContext or param_name == "context":
+                kwargs[param_name] = context
+                continue
+
+            # 2. Map RasterIn
+            if annotation is RasterIn:
+                art = inputs.get(param_name)
+                if not art:
+                    art = next((a for a in inputs.values() if a.kind == "raster_ref"), None)
+                if not art:
+                    available = context.metadata.get("available_inputs", [])
+                    if param_name in available or any(param_name in str(x) for x in available) or "band" in param_name:
+                        art = ExecutionArtifact.of_payload(
+                            kind="raster_ref",
+                            payload={"path": f"data/{param_name}.tif", "name": param_name, "virtual": True},
+                            produced_by="sdk_context_resolver",
+                        )
+                    else:
+                        raise ValueError(f"Missing raster input for argument '{param_name}'")
+                kwargs[param_name] = RasterIn(art)
+                continue
+
+            # 3. Map VectorIn
+            if annotation is VectorIn:
+                art = inputs.get(param_name)
+                if not art:
+                    art = next((a for a in inputs.values() if a.kind in ("features", "vector")), None)
+                if not art:
+                    available = context.metadata.get("available_inputs", [])
+                    if param_name in available or any(param_name in str(x) for x in available):
+                        art = ExecutionArtifact.of_payload(
+                            kind="features",
+                            payload={"features": [], "name": param_name, "virtual": True},
+                            produced_by="sdk_context_resolver",
+                        )
+                    else:
+                        raise ValueError(f"Missing vector input for argument '{param_name}'")
+                kwargs[param_name] = VectorIn(art)
+                continue
+
+            # 4. Map primitives from step parameters
+            if param_name in step.parameters:
+                kwargs[param_name] = step.parameters[param_name]
+            elif param.default is not inspect.Parameter.empty:
+                kwargs[param_name] = param.default
+            else:
+                raise ValueError(
+                    f"Missing parameter '{param_name}' required by capability '{self._reg.name}'."
+                )
+
+        # Execute target capability
+        if inspect.iscoroutinefunction(self._reg.func):
+            result = await self._reg.func(**kwargs)
+        else:
+            result = self._reg.func(**kwargs)
+
+        # Coerce output back to ExecutionArtifact
+        if isinstance(result, RasterOut):
+            return result.to_artifact(produced_by=self.name)
+        if isinstance(result, VectorOut):
+            return result.to_artifact(produced_by=self.name)
+        if isinstance(result, ExecutionArtifact):
+            return result
+
+        # Default fallback
+        return ExecutionArtifact.of_payload(
+            kind="payload",
+            payload={"result": result},
+            produced_by=self.name,
+        )
+
+
+class SDKPlanner(BasePlanner):
+    """
+    Dynamic Planner generated by the SDK.
+    Routes queries to the generated Step Handler.
+    """
+
+    def __init__(self, plugin_id: str, reg: CapabilityRegistration) -> None:
+        self._plugin_id = plugin_id
+        self._reg = reg
+        self._step_type = f"sdk.{plugin_id}.{reg.name}"
+
+    @property
+    def name(self) -> str:
+        return f"planner_{self._plugin_id}_{self._reg.func.__name__}"
+
+    @property
+    def priority(self) -> int:
+        return 100
+
+    def match_score(self, query_ir: QueryIR, context: ExecutionContext) -> float:
+        routing = context.metadata.get("routing") or {}
+        selected = routing.get("selected") or []
+        if self._reg.name in selected:
+            return 1.0
+
+        raw = (query_ir.raw_text or "").lower()
+        if any(kw.lower() in raw for kw in self._reg.keywords):
+            return 0.8
+
+        return 0.0
+
+    async def build_plan(self, query_ir: QueryIR, context: ExecutionContext) -> QueryPlan:
+        params: dict[str, Any] = {}
+        for entity in query_ir.entities:
+            params[entity.role] = entity.name
+
+        if query_ir.constraints.radius_m:
+            params["radius_m"] = query_ir.constraints.radius_m
+        if query_ir.constraints.limit:
+            params["limit"] = query_ir.constraints.limit
+
+        step = PlanStep(
+            type=self._step_type,
+            name=f"step_{self._reg.name}",
+            parameters=params,
+            metadata={"plugin_id": self._plugin_id},
+        )
+
+        return QueryPlan(
+            query_ir_id=query_ir.id,
+            steps=[step],
+            metadata={"plugin_id": self._plugin_id, "source": self._plugin_id},
+        )
+
+
+class SDKResultFusion(BaseResultFusion):
+    """
+    Default dynamic result fusion for SDK plugins.
+    """
+
+    def __init__(self, plugin_id: str) -> None:
+        self._plugin_id = plugin_id
+
+    @property
+    def name(self) -> str:
+        return f"fusion_{self._plugin_id}"
+
+    @property
+    def priority(self) -> int:
+        return 100
+
+    def match_score(
+        self,
+        query_ir: QueryIR,
+        plan: QueryPlan,
+        artifacts: dict[str, ExecutionArtifact],
+        context: ExecutionContext,
+    ) -> float:
+        if plan.metadata.get("plugin_id") == self._plugin_id:
+            return 1.0
+        return 0.0
+
+    async def fuse(
+        self,
+        query_ir: QueryIR,
+        plan: QueryPlan,
+        artifacts: dict[str, ExecutionArtifact],
+        context: ExecutionContext,
+    ) -> GeoResponse:
+        response = GeoResponse.success(
+            query_ir_id=query_ir.id,
+            request_id=context.request_id,
+        )
+        response.metadata["plugin_id"] = self._plugin_id
+        response.metadata["source"] = self._plugin_id
+
+        has_features = False
+        for art in artifacts.values():
+            if art.kind == "features":
+                features_list = art.payload.get("features", [])
+                from geochat_kernel.models.feature_group import FeatureGroup
+                from geochat_kernel.models.geo_feature import GeoFeature
+
+                f_objs = [GeoFeature.from_dict(f) for f in features_list]
+                response.features.extend(f_objs)
+                response.groups.append(
+                    FeatureGroup(
+                        id=f"{self._plugin_id}_group",
+                        label="نتایج پردازش SDK",
+                        features=f_objs,
+                    )
+                )
+                has_features = True
+            elif art.kind == "raster_ref":
+                response.metadata["raster_path"] = art.payload.get("path")
+                response.metadata["raster_meta"] = art.payload
+
+        if has_features:
+            response.user_message.summary = (
+                f"پردازش SDK با موفقیت انجام شد. {len(response.features)} عارضه یافت شد."
+            )
+        else:
+            response.user_message.summary = "پردازش SDK با موفقیت انجام شد."
+
+        return response
+
+
+class SDKPlugin(BasePlugin):
+    """
+    High-level Plugin class. Automates registry mappings and setup.
+    """
+
+    def __init__(self, manifest: PluginManifest | None = None) -> None:
+        self._manifest = manifest or self._build_default_manifest()
+        self._capabilities_regs: list[CapabilityRegistration] = []
+        self._collect_capabilities()
+
+    def _build_default_manifest(self) -> PluginManifest:
+        return PluginManifest(
+            id=self.__class__.__name__.lower(),
+            version="0.1.0",
+            name=self.__class__.__name__,
+        )
+
+    @property
+    def manifest(self) -> PluginManifest:
+        return self._manifest
+
+    def _collect_capabilities(self) -> None:
+        for _, attr in inspect.getmembers(self):
+            reg = getattr(attr, "__geochat_capability__", None)
+            if isinstance(reg, CapabilityRegistration):
+                reg.func = attr
+                self._capabilities_regs.append(reg)
+
+    async def register(self, container) -> None:
+        for reg in self._capabilities_regs:
+            descriptor = reg.build_descriptor(self.id)
+            container.capabilities.register(descriptor, replace=True)
+
+            container.planners.register_planner(
+                SDKPlanner(self.id, reg),
+                replace=True,
+            )
+
+            container.step_handlers.register_handler(
+                SDKStepHandler(self.id, reg),
+                replace=True,
+            )
+
+        if self._capabilities_regs:
+            container.fusions.register_fusion(
+                SDKResultFusion(self.id),
+                replace=True,
+            )
+
+
+def auto_collect(
+    id: str,
+    version: str = "0.1.0",
+    name: str | None = None,
+    description: str | None = None,
+    author: str | None = None,
+    permissions: list[Any] | None = None,
+) -> SDKPlugin:
+    """
+    Collects all module-level decorated functions and bundles them into an SDKPlugin.
+    """
+    regs = list(_PENDING_CAPABILITIES)
+    _PENDING_CAPABILITIES.clear()
+
+    perm_list = []
+    if permissions:
+        for p in permissions:
+            perm_list.append(p.value if hasattr(p, "value") else str(p))
+
+    manifest = PluginManifest(
+        id=id,
+        version=version,
+        name=name or id.replace("_", " ").title(),
+        description=description,
+        author=author,
+        permissions=perm_list,
+    )
+
+    plugin = SDKPlugin(manifest)
+    plugin._capabilities_regs.extend(regs)
+    return plugin

geochat_sdk-1.0.0/geochat_sdk/types/__init__.py

@@ -0,0 +1,7 @@
+# geochat_sdk/types/__init__.py
+from __future__ import annotations
+
+from geochat_sdk.types.raster import RasterIn, RasterOut
+from geochat_sdk.types.vector import VectorIn, VectorOut
+
+__all__ = ["RasterIn", "RasterOut", "VectorIn", "VectorOut"]

geochat_sdk-1.0.0/geochat_sdk/types/raster.py

@@ -0,0 +1,104 @@
+# geochat_sdk/types/raster.py
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any
+
+from geochat_kernel.models.execution_artifact import ExecutionArtifact
+
+
+class RasterIn:
+    """
+    Wrapper for input Raster data.
+    Provides lazy-loaded helper methods for RS specialists.
+    """
+
+    def __init__(self, artifact: ExecutionArtifact) -> None:
+        self.artifact = artifact
+
+    @property
+    def path(self) -> str:
+        payload = self.artifact.payload or {}
+        return payload.get("path") or payload.get("url") or ""
+
+    @property
+    def metadata(self) -> dict[str, Any]:
+        return self.artifact.payload or {}
+
+    def read_numpy(self, band: int = 1) -> Any:
+        """Read raster band as numpy array. Lazy imports numpy and rasterio."""
+        try:
+            import numpy as np
+            import rasterio
+        except ImportError as exc:
+            from geochat_sdk.exceptions import SDKDependencyError
+            raise SDKDependencyError(
+                "numpy and rasterio are required to read raster data. "
+                "Please install them in your plugin environment."
+            ) from exc
+
+        if not self.path or not Path(self.path).exists():
+            raise FileNotFoundError(f"Raster file not found: {self.path}")
+
+        with rasterio.open(self.path) as src:
+            return src.read(band)
+
+    def get_profile(self) -> dict[str, Any]:
+        """Get raster profile metadata."""
+        try:
+            import rasterio
+        except ImportError as exc:
+            from geochat_sdk.exceptions import SDKDependencyError
+            raise SDKDependencyError(
+                "rasterio is required to read raster profile."
+            ) from exc
+
+        with rasterio.open(self.path) as src:
+            return dict(src.profile)
+
+
+class RasterOut:
+    """
+    Wrapper for output Raster data produced by a plugin.
+    """
+
+    def __init__(self, path: str, metadata: dict[str, Any] | None = None) -> None:
+        self.path = path
+        self.metadata = metadata or {}
+
+    @classmethod
+    def from_numpy(cls, data: Any, profile: dict[str, Any], output_path: str) -> RasterOut:
+        """Write numpy array to a GeoTIFF file using rasterio."""
+        try:
+            import numpy as np
+            import rasterio
+        except ImportError as exc:
+            from geochat_sdk.exceptions import SDKDependencyError
+            raise SDKDependencyError(
+                "numpy and rasterio are required to write raster data."
+            ) from exc
+
+        out_path = Path(output_path)
+        out_path.parent.mkdir(parents=True, exist_ok=True)
+
+        # Update profile with single band and correct dtype
+        profile.update(
+            count=1 if len(data.shape) == 2 else data.shape[0],
+            dtype=str(data.dtype),
+        )
+
+        with rasterio.open(str(out_path), "w", **profile) as dst:
+            if len(data.shape) == 2:
+                dst.write(data, 1)
+            else:
+                for i in range(data.shape[0]):
+                    dst.write(data[i], i + 1)
+
+        return cls(path=str(out_path), metadata={"profile": profile})
+
+    def to_artifact(self, produced_by: str) -> ExecutionArtifact:
+        return ExecutionArtifact.of_payload(
+            kind="raster_ref",
+            payload={"path": self.path, **self.metadata},
+            produced_by=produced_by,
+        )

geochat_sdk-1.0.0/geochat_sdk/types/vector.py

@@ -0,0 +1,78 @@
+# geochat_sdk/types/vector.py
+from __future__ import annotations
+
+import json
+from typing import Any
+
+from geochat_kernel.models.execution_artifact import ExecutionArtifact
+
+
+class VectorIn:
+    """
+    Wrapper for input Vector/GeoJSON data.
+    Provides lazy-loaded helper methods for GIS specialists.
+    """
+
+    def __init__(self, artifact: ExecutionArtifact) -> None:
+        self.artifact = artifact
+
+    @property
+    def features(self) -> list[dict[str, Any]]:
+        payload = self.artifact.payload or {}
+        if "features" in payload:
+            return payload["features"]
+        return []
+
+    def to_geopandas(self) -> Any:
+        """Convert features to a GeoPandas GeoDataFrame."""
+        try:
+            import geopandas as gpd
+        except ImportError as exc:
+            from geochat_sdk.exceptions import SDKDependencyError
+            raise SDKDependencyError(
+                "geopandas is required to convert vector data to GeoDataFrame."
+            ) from exc
+
+        if not self.features:
+            return gpd.GeoDataFrame()
+        return gpd.GeoDataFrame.from_features(self.features)
+
+    def to_shapely(self) -> list[Any]:
+        """Convert features to Shapely geometries."""
+        try:
+            from shapely.geometry import shape
+        except ImportError as exc:
+            from geochat_sdk.exceptions import SDKDependencyError
+            raise SDKDependencyError(
+                "shapely is required to parse vector geometries."
+            ) from exc
+
+        geoms = []
+        for f in self.features:
+            if "geometry" in f:
+                geoms.append(shape(f["geometry"]))
+        return geoms
+
+
+class VectorOut:
+    """
+    Wrapper for output Vector/GeoJSON data produced by a plugin.
+    """
+
+    def __init__(self, features: list[dict[str, Any]], metadata: dict[str, Any] | None = None) -> None:
+        self.features = features
+        self.metadata = metadata or {}
+
+    @classmethod
+    def from_geopandas(cls, gdf: Any) -> VectorOut:
+        """Create VectorOut from a GeoDataFrame."""
+        geojson_str = gdf.to_json()
+        geojson = json.loads(geojson_str)
+        return cls(features=geojson.get("features", []))
+
+    def to_artifact(self, produced_by: str) -> ExecutionArtifact:
+        return ExecutionArtifact.of_payload(
+            kind="features",
+            payload={"features": self.features, **self.metadata},
+            produced_by=produced_by,
+        )

geochat_sdk-1.0.0/geochat_sdk.egg-info/PKG-INFO

@@ -0,0 +1,28 @@
+Metadata-Version: 2.4
+Name: geochat-sdk
+Version: 1.0.0
+Summary: Lightweight SDK for building GeoChat Spatial AI plugins
+Author: Araz Shah
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/arazshah/geochat-platform
+Project-URL: Repository, https://github.com/arazshah/geochat-platform
+Project-URL: Issues, https://github.com/arazshah/geochat-platform/issues
+Keywords: geospatial,gis,plugins,spatial-analysis,geoai
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Scientific/Engineering :: GIS
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: pydantic>=2.0.0
+Requires-Dist: geochat-kernel>=1.0.0
+Dynamic: license-file
+
+# GeoChat SDK
+This SDK provides decorators and domain models to build trusted spatial plugins for the GeoChat Core Engine.

geochat_sdk-1.0.0/geochat_sdk.egg-info/SOURCES.txt

@@ -0,0 +1,15 @@
+LICENSE
+README.md
+pyproject.toml
+geochat_sdk/__init__.py
+geochat_sdk/decorators.py
+geochat_sdk/exceptions.py
+geochat_sdk/plugin.py
+geochat_sdk.egg-info/PKG-INFO
+geochat_sdk.egg-info/SOURCES.txt
+geochat_sdk.egg-info/dependency_links.txt
+geochat_sdk.egg-info/requires.txt
+geochat_sdk.egg-info/top_level.txt
+geochat_sdk/types/__init__.py
+geochat_sdk/types/raster.py
+geochat_sdk/types/vector.py

geochat_sdk-1.0.0/geochat_sdk.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

geochat_sdk-1.0.0/geochat_sdk.egg-info/requires.txt

@@ -0,0 +1,2 @@
+pydantic>=2.0.0
+geochat-kernel>=1.0.0

geochat_sdk-1.0.0/geochat_sdk.egg-info/top_level.txt

@@ -0,0 +1 @@
+geochat_sdk

geochat_sdk-1.0.0/pyproject.toml

@@ -0,0 +1,43 @@
+[build-system]
+requires = ["setuptools>=77", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "geochat-sdk"
+version = "1.0.0"
+description = "Lightweight SDK for building GeoChat Spatial AI plugins"
+readme = "README.md"
+requires-python = ">=3.10"
+license = "MIT"
+license-files = ["LICENSE"]
+authors = [{ name = "Araz Shah" }]
+keywords = ["geospatial", "gis", "plugins", "spatial-analysis", "geoai"]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Developers",
+    "Intended Audience :: Science/Research",
+    "Operating System :: OS Independent",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Topic :: Scientific/Engineering :: GIS",
+]
+dependencies = [
+    "pydantic>=2.0.0",
+    # geochat_sdk imports geochat_kernel at module level in 13 places
+    # (decorators.py, plugin.py, types/raster.py, types/vector.py), so
+    # importing this package without the kernel installed fails outright.
+    # The dependency runs sdk -> kernel, NOT kernel -> sdk: geochat_kernel
+    # contains no reference to geochat_sdk at all.
+    "geochat-kernel>=1.0.0",
+]
+
+[project.urls]
+Homepage = "https://github.com/arazshah/geochat-platform"
+Repository = "https://github.com/arazshah/geochat-platform"
+Issues = "https://github.com/arazshah/geochat-platform/issues"
+
+[tool.setuptools.packages.find]
+where = ["."]
+include = ["geochat_sdk*"]

geochat_sdk-1.0.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+