geobox 2.2.0__tar.gz → 2.2.2__tar.gz

{geobox-2.2.0 → geobox-2.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: geobox
-Version: 2.2.0
+Version: 2.2.2
 Summary: SDK for Geobox's APIs
 Author-email: Hamid Heydari <heydari.h62@gmail.com>
 License: MIT

{geobox-2.2.0 → geobox-2.2.2}/geobox/aio/feature.py

@@ -29,7 +29,11 @@ class AsyncFeature(AsyncBase):
         super().__init__(api=layer.api)
         self.layer = layer
         self._srid = srid
-        self.data = data or {}
+        self.data = data or {
+            "type": "Feature",
+            "geometry": {},
+            "properties": {}
+        }
         self.original_geometry = self.data.get('geometry')
         self.endpoint = urljoin(layer.endpoint, f'features/{self.data.get("id")}/') if self.data.get('id') else None
 
@@ -58,7 +62,8 @@ class AsyncFeature(AsyncBase):
         Returns:
             str: A string representation of the Feature object.
         """
-        return f"AsyncFeature(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:
@@ -210,18 +215,27 @@ class AsyncFeature(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:
         """
@@ -267,13 +281,14 @@ class AsyncFeature(AsyncBase):
     
 
     @classmethod
-    async def create_feature(cls, layer: 'VectorLayer', geojson: Dict) -> 'AsyncFeature':
+    async def create_feature(cls, layer: 'VectorLayer', geojson: Dict, srid: int = 3857) -> 'AsyncFeature':
         """
         [async] Create a new feature in the vector layer.
 
         Args:
             layer (VectorLayer): The vector layer to create the feature in
             geojson (Dict): The GeoJSON data for the feature
+            srid (int, optional): the feature srid. default: 3857
 
         Returns:
             AsyncFeature: The created feature instance
@@ -289,8 +304,19 @@ class AsyncFeature(AsyncBase):
             ...     }
             >>>     feature = await Feature.create_feature(layer, geojson)
         """
+        feature = AsyncFeature(layer, srid=srid, data=geojson)
+        data = feature.data.copy()
+        srid = feature.srid
+
+        if feature.srid != feature.BASE_SRID:
+            feature = feature.transform(feature.BASE_SRID)
+
         endpoint = urljoin(layer.endpoint, 'features/')
-        return await cls._create(layer.api, endpoint, geojson, factory_func=lambda api, item: AsyncFeature(layer, data=item))
+        
+        feature = await cls._create(layer.api, endpoint, feature.data, factory_func=lambda api, item: AsyncFeature(layer, data=item))
+        feature.data['geometry'] = data['geometry']
+        feature._srid = srid
+        return feature
 
 
     @classmethod
@@ -350,10 +376,7 @@ class AsyncFeature(AsyncBase):
                 "Install it with: pip install geobox[geometry]"
             )
         
-        if not self.data:
-            return None
-        
-        elif not self.data.get('geometry'):
+        if not self.data.get('geometry'):
             raise ValueError("Geometry is not present in the feature data")
         
         elif not isinstance(self.data['geometry'], dict):

{geobox-2.2.0 → geobox-2.2.2}/geobox/aio/task.py

@@ -2,6 +2,7 @@ import time
 import asyncio
 from urllib.parse import urljoin
 from typing import Optional, Dict, List, Optional, Union, TYPE_CHECKING
+import logging
 
 from .base import AsyncBase
 from ..enums import TaskStatus
@@ -16,6 +17,8 @@ if TYPE_CHECKING:
     from ..api import GeoboxClient
     from ..task import Task
 
+logger = logging.getLogger(__name__)
+
 
 class AsyncTask(AsyncBase):
 
@@ -233,7 +236,7 @@ class AsyncTask(AsyncBase):
                 return await self._wait(timeout, interval, progress_bar)
             except Exception as e:
                 last_exception = e
-                print(f"[Retry {attempt}/{retry}] Task wait failed: {e}")
+                logger.warning(f"[Retry {attempt}/{retry}] Task wait failed: {e}")
                 time.sleep(interval)
         raise last_exception
 

{geobox-2.2.0 → geobox-2.2.2}/geobox/aio/vectorlayer.py

@@ -755,12 +755,13 @@ class AsyncVectorLayer(AsyncBase):
         return feature
 
 
-    async def create_feature(self, geojson: Dict)-> 'AsyncFeature':
+    async def create_feature(self, geojson: Dict, srid: int = AsyncFeature.BASE_SRID)-> 'AsyncFeature':
         """
         [async] Create a new feature in the layer.
         
         Args:
             geojson (Dict): The feature data including properties and geometry.
+            srid (int, optional): the feature srid. default: 3857
             
         Returns:
             Feature: The newly created feature instance.
@@ -780,7 +781,7 @@ class AsyncVectorLayer(AsyncBase):
             ...     }
             >>>     feature = await layer.create_feature(geojson=geojson)
         """
-        return await AsyncFeature.create_feature(self, geojson)
+        return await AsyncFeature.create_feature(self, geojson, srid=srid)
 
 
     async def delete_features(self, 

{geobox-2.2.0 → geobox-2.2.2}/geobox/feature.py

@@ -30,13 +30,27 @@ class Feature(Base):
             >>> 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
+            >>> geojson = {
+            ...     "type": "Feature",
+            ...     "geometry": {
+            ...         "type": "Point",
+            ...         "coordinates": [10.0, 10.0]
+            ...     },
+            ...     "properties": {
+            ...         "name": "Test feature"
+            ...     }
+            ... }
+            >>> feature = Feature(layer=layer, data=geojson, srid=4326) # example srid set to 4326
             >>> feature.save()
         """
         super().__init__(api=layer.api)
         self.layer = layer
         self._srid = srid
-        self.data = data or {}
+        self.data = data or {
+            "type": "Feature",
+            "geometry": {},
+            "properties": {}
+        }
         self.original_geometry = self.data.get('geometry')
         self.endpoint = urljoin(layer.endpoint, f'features/{self.data.get("id")}/') if self.data.get('id') else None
 
@@ -65,8 +79,9 @@ class Feature(Base):
         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"Feature(id={feature_id}, type={self.feature_type})"
+        
 
     def __getattr__(self, name: str) -> Any:
         """
@@ -217,18 +232,28 @@ class Feature(Base):
             >>> 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
                 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 = self.layer.api.post(endpoint, data)
+            request_data = self.data.copy()
+            response = 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
+
+
 
     def delete(self) -> None:
         """
@@ -274,13 +299,14 @@ class Feature(Base):
     
 
     @classmethod
-    def create_feature(cls, layer: 'VectorLayer', geojson: Dict) -> 'Feature':
+    def create_feature(cls, layer: 'VectorLayer', geojson: Dict, srid: int = 3857) -> 'Feature':
         """
         Create a new feature in the vector layer.
 
         Args:
             layer (VectorLayer): The vector layer to create the feature in
             geojson (Dict): The GeoJSON data for the feature
+            srid (int, optional): the feature srid. default: 3857
 
         Returns:
             Feature: The created feature instance
@@ -297,8 +323,19 @@ class Feature(Base):
             ... }
             >>> feature = Feature.create_feature(layer, geojson)
         """
+        feature = Feature(layer, srid=srid, data=geojson)
+        data = feature.data.copy()
+        srid = feature.srid
+
+        if feature.srid != feature.BASE_SRID:
+            feature = feature.transform(feature.BASE_SRID)
+
         endpoint = urljoin(layer.endpoint, 'features/')
-        return cls._create(layer.api, endpoint, geojson, factory_func=lambda api, item: Feature(layer, data=item))
+        
+        feature = cls._create(layer.api, endpoint, feature.data, factory_func=lambda api, item: Feature(layer, data=item))
+        feature.data['geometry'] = data['geometry']
+        feature._srid = srid
+        return feature
 
 
     @classmethod
@@ -359,10 +396,8 @@ class Feature(Base):
                 "Install it with: pip install geobox[geometry]"
             )
         
-        if not self.data:
-            return None
         
-        elif not self.data.get('geometry'):
+        if not self.data.get('geometry'):
             raise ValueError("Geometry is not present in the feature data")
         
         elif not isinstance(self.data['geometry'], dict):

{geobox-2.2.0 → geobox-2.2.2}/geobox/task.py

@@ -1,6 +1,7 @@
 from urllib.parse import urljoin, urlencode
 from typing import Optional, Dict, List, Optional, Union, TYPE_CHECKING
 import time
+import logging
 
 from .base import Base
 from .enums import TaskStatus
@@ -15,6 +16,8 @@ if TYPE_CHECKING:
     from .aio import AsyncGeoboxClient
     from .aio.task import AsyncTask
 
+logger = logging.getLogger(__name__)
+
 
 class Task(Base):
 
@@ -230,7 +233,7 @@ class Task(Base):
                 return self._wait(timeout, interval, progress_bar)
             except Exception as e:
                 last_exception = e
-                print(f"[Retry {attempt}/{retry}] Task wait failed: {e}")
+                logger.warning(f"[Retry {attempt}/{retry}] Task wait failed: {e}")
                 time.sleep(interval)
         raise last_exception
 

{geobox-2.2.0 → geobox-2.2.2}/geobox/vectorlayer.py

@@ -756,12 +756,13 @@ class VectorLayer(Base):
         return feature
 
 
-    def create_feature(self, geojson: Dict)-> 'Feature':
+    def create_feature(self, geojson: Dict, srid: int = Feature.BASE_SRID)-> 'Feature':
         """
         Create a new feature in the layer.
         
         Args:
             geojson (Dict): The feature data including properties and geometry.
+            srid (int, optional): the feature srid. default: 3857
             
         Returns:
             Feature: The newly created feature instance.
@@ -781,7 +782,7 @@ class VectorLayer(Base):
             ... }
             >>> feature = layer.create_feature(geojson=geojson)
         """
-        return Feature.create_feature(self, geojson)
+        return Feature.create_feature(self, geojson, srid=srid)
 
 
     def delete_features(self, q: str = None, bbox: str = None, bbox_srid: int = None, feature_ids: List[int] = None, 

{geobox-2.2.0 → geobox-2.2.2}/geobox.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: geobox
-Version: 2.2.0
+Version: 2.2.2
 Summary: SDK for Geobox's APIs
 Author-email: Hamid Heydari <heydari.h62@gmail.com>
 License: MIT

{geobox-2.2.0 → geobox-2.2.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "geobox"
-version = "2.2.0"
+version = "2.2.2"
 description = "SDK for Geobox's APIs"
 authors = [
   {name = "Hamid Heydari", email = "heydari.h62@gmail.com"}

{geobox-2.2.0 → geobox-2.2.2}/tests/test_feature.py

@@ -107,6 +107,26 @@ def test_save_srid(api, mock_vector_data, mock_feature_data, feature_type):
     assert feature.srid == 3857
     assert feature.coordinates == coords
 
+    # without id
+    feature_id = feature_data['id']
+    del feature_data['id']
+    # Mock response should include the id as the API returns the created feature with id
+    response_data = feature_data.copy()
+    response_data['id'] = feature_id
+    api.post.return_value = response_data
+    feature = Feature(layer, srid=3857, data=feature_data)
+    feature.transform(4326)
+    coords = feature.coordinates
+    feature.save()
+    assert feature.srid == 4326
+    assert feature.coordinates == coords
+
+    feature = Feature(layer, srid=3857, data=feature_data)
+    coords = feature.coordinates
+    feature.save()
+    assert feature.srid == 3857
+    assert feature.coordinates == coords
+
 
 @pytest.mark.parametrize("feature_type", [type.value for type in FeatureType])
 def test_delete(api, mock_vector_data, mock_feature_data, feature_type):
@@ -159,7 +179,7 @@ def test_create_feature(api, mock_vector_data, mock_feature_data, feature_type):
     
     feature = Feature.create_feature(
         layer=layer, 
-        geojson=expected_request
+        geojson=expected_request,
     )
     api.post.assert_called_once_with(f'{layer.endpoint}features/', expected_request)
     assert isinstance(feature, Feature)
@@ -168,6 +188,39 @@ def test_create_feature(api, mock_vector_data, mock_feature_data, feature_type):
     assert feature.data == api_response
 
 
+@pytest.mark.parametrize("feature_type", [type.value for type in FeatureType])
+def test_create_feature_with_srid(api, mock_vector_data, mock_feature_data, feature_type):
+    """Test creating a feature for different geometry types"""
+    layer = VectorLayer(api, uuid=mock_vector_data['uuid'], layer_type=LayerType.MultiPoint, data=mock_vector_data)
+    feature_data = mock_feature_data[feature_type]
+    
+    expected_request = {
+        'type': 'Feature',
+        'geometry': feature_data['geometry'],
+        'properties': {'name': f'test_{feature_type.lower()}'}
+    }
+    
+    api_response = {
+        'type': 'Feature',
+        'geometry': feature_data['geometry'],
+        'properties': {'name': f'test_{feature_type.lower()}'},
+        'id': feature_data['id'],
+        'bbox': feature_data['bbox']
+    }
+    api.post.return_value = api_response
+    
+    feature = Feature.create_feature(
+        layer=layer, 
+        geojson=expected_request,
+        srid=4326
+    )
+    api.post.assert_called_once_with(f'{layer.endpoint}features/', expected_request)
+    assert isinstance(feature, Feature)
+    assert feature.layer == layer
+    assert feature.srid == 4326
+    assert feature.data == api_response
+
+
 @pytest.mark.parametrize("feature_type", [type.value for type in FeatureType])
 def test_get_feature(api, mock_vector_data, mock_feature_data, feature_type):
     """Test getting a feature for different geometry types"""
@@ -200,8 +253,8 @@ def test_geometry_no_data(api, mock_vector_data):
     layer = VectorLayer(api, uuid=mock_vector_data['uuid'], layer_type=LayerType('Point'), data=mock_vector_data)
     feature = Feature(layer, srid=3857, data=None)  # No data
     
-    result = feature.geometry
-    assert result is None
+    with pytest.raises(ValueError, match="Geometry is not present in the feature data"):
+        feature.geometry
 
 
 def test_geometry_no_geometry_field(api, mock_vector_data):