geobox 2.1.0__py3-none-any.whl → 2.2.1__py3-none-any.whl

geobox/aio/feature.py

@@ -6,18 +6,18 @@ from ..enums import FeatureType
 
 if TYPE_CHECKING:
     from .vectorlayer import VectorLayer
-    from ..api import GeoboxClient as SyncGeoboxClient
-    from ..feature import Feature as SyncFeature
+    from ..api import GeoboxClient
+    from ..feature import Feature
 
 
-class Feature(AsyncBase):
+class AsyncFeature(AsyncBase):
 
     BASE_SRID = 3857
 
     def __init__(self, 
-                 layer: 'VectorLayer', 
-                 srid: Optional[int] = 3857,
-                 data: Optional[Dict] = {}):
+        layer: 'VectorLayer', 
+        srid: Optional[int] = 3857,
+        data: Optional[Dict] = {}):
         """
         Constructs all the necessary attributes for the Feature object.
 
@@ -25,13 +25,6 @@ class Feature(AsyncBase):
             layer (VectorLayer): The vector layer this feature belongs to
             srid (int, optional): The Spatial Reference System Identifier (default is 3857)
             data (Dict, optional): The feature data contains the feature geometry and properties
-
-        Example:
-            >>> from geobox import GeoboxClient, Feature
-            >>> client = GeoboxClient()
-            >>> layer = client.get_vector(uuid="12345678-1234-5678-1234-567812345678")
-            >>> feature = Feature(layer=layer, srid=4326) # example srid set to 4326
-            >>> feature.save()
         """
         super().__init__(api=layer.api)
         self.layer = layer
@@ -65,7 +58,8 @@ class Feature(AsyncBase):
         Returns:
             str: A string representation of the Feature object.
         """
-        return f"Feature(id={self.id}, type={self.feature_type})"
+        feature_id = getattr(self, "id", "-1")
+        return f"AsyncFeature(id={feature_id}, type={self.feature_type})"
     
 
     def __getattr__(self, name: str) -> Any:
@@ -217,18 +211,27 @@ class Feature(AsyncBase):
             >>>     await feature.save()
         """
         data = self.data.copy()
+        srid = self.srid
+
         try:
             if self.id:
                 if self.srid != self.BASE_SRID:
-                    self.data['geometry'] = self.original_geometry
+                    self = self.transform(self.BASE_SRID)
+                self.data['geometry'] = self.original_geometry
                 await self.update(self.data)
                 self.coordinates = data['geometry']['coordinates']
         except AttributeError:
+            if self.srid != self.BASE_SRID:
+                self = self.transform(self.BASE_SRID)
             endpoint = urljoin(self.layer.endpoint, 'features/')
-            response = await self.layer.api.post(endpoint, data)
+            request_data = self.data.copy()
+            response = await self.layer.api.post(endpoint, request_data)
             self.endpoint = urljoin(self.layer.endpoint, f'features/{response["id"]}/')        
             self.data.update(response)
 
+        self.data['geometry'] = data['geometry']
+        self._srid = srid
+
 
     async def delete(self) -> None:
         """
@@ -244,7 +247,7 @@ class Feature(AsyncBase):
             >>>     feature = await layer.get_feature(id=1)
             >>>     await feature.delete()
         """
-        await super().delete(self.endpoint)
+        await super()._delete(self.endpoint)
 
 
     async def update(self, geojson: Dict) -> Dict:
@@ -274,7 +277,7 @@ class Feature(AsyncBase):
     
 
     @classmethod
-    async def create_feature(cls, layer: 'VectorLayer', geojson: Dict) -> 'Feature':
+    async def create_feature(cls, layer: 'VectorLayer', geojson: Dict) -> 'AsyncFeature':
         """
         [async] Create a new feature in the vector layer.
 
@@ -283,7 +286,7 @@ class Feature(AsyncBase):
             geojson (Dict): The GeoJSON data for the feature
 
         Returns:
-            Feature: The created feature instance
+            AsyncFeature: The created feature instance
 
         Example:
             >>> from geobox.aio import AsyncGeoboxClient
@@ -297,11 +300,11 @@ class Feature(AsyncBase):
             >>>     feature = await Feature.create_feature(layer, geojson)
         """
         endpoint = urljoin(layer.endpoint, 'features/')
-        return await cls._create(layer.api, endpoint, geojson, factory_func=lambda api, item: Feature(layer, data=item))
+        return await cls._create(layer.api, endpoint, geojson, factory_func=lambda api, item: AsyncFeature(layer, data=item))
 
 
     @classmethod
-    async def get_feature(cls, layer: 'VectorLayer', feature_id: int, user_id: int = None) -> 'Feature':
+    async def get_feature(cls, layer: 'VectorLayer', feature_id: int, user_id: int = None) -> 'AsyncFeature':
         """
         [async] Get a feature by its ID.
 
@@ -311,21 +314,21 @@ class Feature(AsyncBase):
             user_id (int): specific user. privileges required.
 
         Returns:
-            Feature: The retrieved feature instance
+            AsyncFeature: The retrieved feature instance
 
         Example:
             >>> from geobox.aio import AsyncGeoboxClient
-            >>> from geobox.aio.feature import Feature
+            >>> from geobox.aio.feature import AsyncFeature
             >>> async with AsyncGeoboxClient() as client:
             >>>     layer = await client.get_vector(uuid="12345678-1234-5678-1234-567812345678")
-            >>>     feature = await Feature.get_feature(layer, feature_id=1)
+            >>>     feature = await AsyncFeature.get_feature(layer, feature_id=1)
         """
         param = {
             'f': 'json',
             'user_id': user_id
         }
         endpoint = urljoin(layer.endpoint, f'features/')
-        return await cls._get_detail(layer.api, endpoint, uuid=feature_id, params=param, factory_func=lambda api, item: Feature(layer, data=item))
+        return await cls._get_detail(layer.api, endpoint, uuid=feature_id, params=param, factory_func=lambda api, item: AsyncFeature(layer, data=item))
 
 
     @property
@@ -344,7 +347,6 @@ class Feature(AsyncBase):
 
         Example:
             >>> from geobox.aio import AsyncGeoboxClient
-            >>> from geobox.aio.feature import Feature
             >>> async with AsyncGeoboxClient() as client:
             >>>     layer = await client.get_vector(uuid="12345678-1234-5678-1234-567812345678")
             >>>     feature = await layer.get_feature(id=1)
@@ -395,7 +397,6 @@ class Feature(AsyncBase):
 
         Example:
             >>> from geobox.aio import AsyncGeoboxClient
-            >>> from geobox.aio.feature import Feature
             >>> from shapely.affinity import translate
             >>> async with AsyncGeoboxClient() as client:
             >>>     layer = await client.get_vector(uuid="12345678-1234-5678-1234-567812345678")
@@ -423,7 +424,7 @@ class Feature(AsyncBase):
             self.data['geometry'] = mapping(value)
 
         
-    def transform(self, out_srid: int) -> 'Feature':
+    def transform(self, out_srid: int) -> 'AsyncFeature':
         """
         Transform the feature geometry to a new SRID.
 
@@ -431,7 +432,7 @@ class Feature(AsyncBase):
             out_srid (int): The target SRID to transform the geometry to (e.g., 4326 for WGS84, 3857 for Web Mercator)
 
         Returns:
-            Feature: A new Feature instance with transformed geometry.
+            AsyncFeature: A new Feature instance with transformed geometry.
 
         Raises:
             ValueError: If the feature has no geometry or if the transformation fails.
@@ -439,7 +440,6 @@ class Feature(AsyncBase):
 
         Example:
             >>> from geobox.aio import AsyncGeoboxClient
-            >>> from geobox.aio.feature import Feature
             >>> async with AsyncGeoboxClient() as client:
             >>>     layer = await client.get_vector(uuid="12345678-1234-5678-1234-567812345678")
             >>>     feature = await layer.get_feature(id=1, srid=3857)
@@ -502,15 +502,15 @@ class Feature(AsyncBase):
         return self
 
 
-    def to_sync(self, sync_client: 'SyncGeoboxClient') -> 'SyncFeature':
+    def to_sync(self, sync_client: 'GeoboxClient') -> 'Feature':
         """
         [async] Switch to sync version of the feature instance to have access to the sync methods
 
         Args:
-            sync_client (SyncGeoboxClient): The sync version of the GeoboxClient instance for making requests.
+            sync_client (GeoboxClient): The sync version of the GeoboxClient instance for making requests.
 
         Returns:
-            geobox.feature.Feature: the sync instance of the feature.
+            Feature: the sync instance of the feature.
 
         Example:
             >>> from geobox import Geoboxclient
@@ -521,7 +521,7 @@ class Feature(AsyncBase):
             >>>     feature = await layer.get_feature(id=1, srid=3857)
             >>>     sync_feature = feature.to_sync(client)
         """
-        from ..feature import Feature as SyncFeature
+        from ..feature import Feature
 
         sync_layer = self.layer.to_sync(sync_client=sync_client)
-        return SyncFeature(layer=sync_layer, srid=self.srid, data=self.data)
+        return Feature(layer=sync_layer, srid=self.srid, data=self.data)