geobox 1.3.2__tar.gz → 1.3.3__tar.gz

{geobox-1.3.2 → geobox-1.3.3}/PKG-INFO

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

{geobox-1.3.2 → geobox-1.3.3}/geobox/api.py

@@ -781,16 +781,14 @@ class GeoboxClient:
         return VectorLayerView.get_view_by_name(self, name, user_id)
 
 
-    def create_tileset(self, name: str, layers: List[Dict], display_name: str = None, description: str = None,
+    def create_tileset(self, name: str, layers: List[Union['VectorLayer', 'VectorLayerView']], display_name: str = None, description: str = None,
                         min_zoom: int = None, max_zoom: int = None, user_id: int = None) -> 'Tileset':
         """
         Create a new tileset.
 
         Args:
             name (str): The name of the tileset.
-            layers (List[Dict]): The layers of the tileset. a list of dictionaries with the following keys:
-                - layer_type: The type of the layer. valid values are "vector" and "view".
-                - layer_uuid: The uuid of the layer.
+            layers (List['VectorLayer' | 'VectorLayerView']): list of vectorlayer and view objects to add to tileset.
             display_name (str, optional): The display name of the tileset.
             description (str, optional): The description of the tileset.
             min_zoom (int, optional): The minimum zoom level of the tileset.
@@ -802,19 +800,16 @@ class GeoboxClient:
 
         Example:
             >>> from geobox import GeoboxClient
+            >>> from geobox.tileset import Tileset
             >>> client = GeoboxClient()
-            >>> layers = [
-            ...     {
-            ...     "layer_type": "vector",
-            ...     "layer_uuid": "12345678-1234-5678-1234-567812345678"
-            ...     }
-            ... ]
+            >>> layer = client.get_vector(uuid="12345678-1234-5678-1234-567812345678")
+            >>> view = client.get_view(uuid="12345678-1234-5678-1234-567812345678")
             >>> tileset = client.create_tileset(name="your_tileset_name", 
             ...                                     display_name="Your Tileset", 
             ...                                     description="Your description", 
             ...                                     min_zoom=0, 
             ...                                     max_zoom=14, 
-            ...                                     layers=layers)
+            ...                                     layers=[layer, view])
         """
         return Tileset.create_tileset(api=self, 
                                       name=name, 

{geobox-1.3.2 → geobox-1.3.3}/geobox/enums.py

@@ -326,12 +326,6 @@ class QueryResultType(Enum):
     both = "both"
 
 
-class TilesetLayerType(Enum):
-    Vector = "vector"
-
-    View = "view"
-
-
 class FileOutputFormat(Enum):
     Shapefile = "Shapefile"
 

{geobox-1.3.2 → geobox-1.3.3}/geobox/query.py

@@ -624,18 +624,16 @@ class Query(Base):
         return endpoint
 
 
-    def save_as_layer(self, layer_name: str, layer_type: 'QueryGeometryType') -> Dict:
+    def save_as_layer(self, layer_name: str, layer_type: 'QueryGeometryType' = None) -> Task:
         """
         Saves the query as a new layer.
 
         Args:
-            sql (str): The SQL statement for the query.
-            params (list): The parameters for the SQL statement.
             layer_name (str): The name of the new layer.
-            layer_type (QueryGeometryType): The type of the new layer.
+            layer_type (QueryGeometryType, optional): The type of the new layer.
 
         Returns:
-            Dict: The response from the API.
+            Task: The response task object.
             
         Raises:
             PermissionError: If the query is a read-only system query.
@@ -645,7 +643,7 @@ class Query(Base):
             >>> from geobox.query import Query
             >>> client = GeoboxClient()
             >>> query = Query.get_query(client, uuid="12345678-1234-5678-1234-567812345678")
-            >>> query.save_as_layer(layer_name='test', layer_type=QueryGeometryType.POLYGON)
+            >>> query.save_as_layer(layer_name='test')
         """
         self._check_access()
 
@@ -659,7 +657,7 @@ class Query(Base):
             "sql": self.sql,
             "params": params,
             "layer_name": layer_name,
-            "layer_type": layer_type.value
+            "layer_type": layer_type.value if layer_type else None
         })
 
         endpoint = urljoin(self.BASE_ENDPOINT, 'saveAsLayer/')

{geobox-1.3.2 → geobox-1.3.3}/geobox/tileset.py

@@ -3,8 +3,8 @@ from typing import Dict, List, Optional, Union, TYPE_CHECKING
 
 from .base import Base
 from .vectorlayer import VectorLayer
+from .view import VectorLayerView
 from .task import Task
-from .enums import TilesetLayerType
 
 if TYPE_CHECKING:
     from . import GeoboxClient 
@@ -35,7 +35,7 @@ class Tileset(Base):
 
 
     @classmethod
-    def create_tileset(cls, api: 'GeoboxClient', name: str, layers: List[Dict], display_name: str = None, description: str = None,
+    def create_tileset(cls, api: 'GeoboxClient', name: str, layers: List[Union['VectorLayer', 'VectorLayerView']], display_name: str = None, description: str = None,
                         min_zoom: int = None, max_zoom: int = None, user_id: int = None) -> 'Tileset':
         """
         Create a new tileset.
@@ -43,9 +43,7 @@ class Tileset(Base):
         Args:
             api (GeoboxClient): The GeoboxClient instance for making requests.
             name (str): The name of the tileset.
-            layers (List[Dict]): The layers of the tileset. a list of dictionaries with the following keys:
-                - layer_type: The type of the layer. valid values are "vector" and "view".
-                - layer_uuid: The uuid of the layer.
+            layers (List['VectorLayer' | 'VectorLayerView']): list of vectorlayer and view objects to add to tileset.
             display_name (str, optional): The display name of the tileset.
             description (str, optional): The description of the tileset.
             min_zoom (int, optional): The minimum zoom level of the tileset.
@@ -59,34 +57,46 @@ class Tileset(Base):
             >>> from geobox import GeoboxClient
             >>> from geobox.tileset import Tileset
             >>> client = GeoboxClient()
-            >>> layers = [
-            ...     {
-            ...     "layer_type": "vector",
-            ...     "layer_uuid": "12345678-1234-5678-1234-567812345678"
-            ...     }
-            ... ]
+            >>> layer = client.get_vector(uuid="12345678-1234-5678-1234-567812345678")
+            >>> view = client.get_view(uuid="12345678-1234-5678-1234-567812345678")
             >>> tileset = Tileset.create_tileset(client, 
             ...                                     name="your_tileset_name", 
             ...                                     display_name="Your Tileset", 
             ...                                     description="Your description", 
             ...                                     min_zoom=0, 
             ...                                     max_zoom=14, 
-            ...                                     layers=layers)
+            ...                                     layers=[layer, view])
             or 
             >>> tileset = client.create_tileset(name="your_tileset_name", 
             ...                                     display_name="Your Tileset", 
             ...                                     description="Your description", 
             ...                                     min_zoom=0, 
             ...                                     max_zoom=14, 
-            ...                                     layers=layers)
+            ...                                     layers=[layer, view])
         """
+        formatted_layers = []
+        for item in layers:
+            if type(item) == VectorLayer:
+                item_type = 'vector'
+
+            elif type(item) == VectorLayerView:
+                item_type = 'view'
+
+            else:
+                continue
+
+            formatted_layers.append({
+                'layer_type': item_type,
+                'layer_uuid': item.uuid
+            })
+
         data = {
             "name": name,
             "display_name": display_name,
             "description": description,
             "min_zoom": min_zoom,
             "max_zoom": max_zoom,
-            "layers": layers,
+            "layers": formatted_layers,
             "user_id": user_id
         }
         return super()._create(api, cls.BASE_ENDPOINT, data, factory_func=lambda api, item: Tileset(api, item['uuid'], item))
@@ -283,7 +293,7 @@ class Tileset(Base):
         super().delete(urljoin(self.BASE_ENDPOINT, f'{self.uuid}/'))
     
     
-    def get_tileset_layers(self, **kwargs) -> List['VectorLayer']:
+    def get_layers(self, **kwargs) -> List['VectorLayer']:
         """
         Retrieves the layers of the tileset with optional parameters.
 
@@ -307,13 +317,14 @@ class Tileset(Base):
         Example:
 
         Returns:
-            List: A list of VectorLayer instances.
+            List: A list of VectorLayer or VectorLayerView instances.
 
         Example:
             >>> from geobox import GeoboxClient
             >>> from geobox.tileset import Tileset
             >>> client = GeoboxClient()
-            >>> tilesets = Tileset.get_tileset_layers()
+            >>> tileset = Tileset.get_tileset(client, uuid="12345678-1234-5678-1234-567812345678")
+            >>> layers = tileset.get_layers()
         """
         params = {
             'f': 'json',
@@ -328,57 +339,82 @@ class Tileset(Base):
             'shared': kwargs.get('shared', False)
         }
         endpoint = urljoin(self.BASE_ENDPOINT, f'{self.uuid}/layers/')
-        return super()._get_list(self.api, endpoint, params, factory_func=lambda api, item: VectorLayer(api, item['uuid'], item['layer_type'], item))
+        return super()._get_list(self.api, endpoint, params, factory_func=lambda api, item: VectorLayer(api, item['uuid'], item['layer_type'], item) if not item['is_view'] else \
+                                                                                            VectorLayerView(api, item['uuid'], item['layer_type'], item)                                    )
 
 
-    def add_layer(self, layer_type: TilesetLayerType, layer_uuid: str) -> None:
+    def add_layer(self, layer: Union['VectorLayer', 'VectorLayerView']) -> None:
         """
         Adds a layer to the tileset.
 
         Args:
-            layer_type (TilesetLayerType): The type of the layer. "vector" or "view".
-            layer_uuid (str): The UUID of the layer.
+            layer (VectorLayer | VectorLayerView): the layer object to add to the tileset
 
         Returns:
             None
 
+        Raises:
+            ValueError: if the layer input is not a 'VectorLayer' or 'VetorLayerview' object
+
         Example:
             >>> from geobox import GeoboxClient
             >>> from geobox.tileset import Tileset
             >>> client = GeoboxClient()
             >>> tileset = Tileset.get_tileset(client, uuid="12345678-1234-5678-1234-567812345678")
-            >>> tileset.add_layer_tileset(layer_type=TilesetLayerType.Vector, layer_uuid="12345678-1234-5678-1234-567812345678")
+            >>> layer = client.get_vector(uuid="12345678-1234-5678-1234-567812345678")
+            >>> tileset.add_layer(layer)
         """
+        if type(layer) == VectorLayer:
+            layer_type = 'vector'
+
+        elif type(layer) == VectorLayerView:
+            layer_type = 'view'
+
+        else:
+            raise ValueError("layer input must be either 'VectorLayer' or 'VetorLayerview' object")
+
         data = {
-            "layer_type": layer_type.value,
-            "layer_uuid": layer_uuid
+            "layer_type": layer_type,
+            "layer_uuid": layer.uuid
         }
 
         endpoint = urljoin(self.endpoint, 'layers/')
         return self.api.post(endpoint, data, is_json=False)
 
 
-    def delete_layer(self, layer_type: TilesetLayerType, layer_uuid: str) -> None:
+    def delete_layer(self, layer: Union['VectorLayer', 'VectorLayerView']) -> None:
         """
         Deletes a layer from the tileset.
 
         Args:
-            layer_type (TilesetLayerType): The type of the layer. "vector" or "view".
-            layer_uuid (str): The UUID of the layer.
+            layer (VectorLayer | VectorLayerView): the layer object to delete from the tileset
 
         Returns:
             None
 
+        Raises:
+            ValueError: if the layer input is not a 'VectorLayer' or 'VetorLayerview' object
+
         Example:
             >>> from geobox import GeoboxClient
             >>> from geobox.tileset import Tileset
             >>> client = GeoboxClient()
             >>> tileset = Tileset.get_tileset(client, uuid="12345678-1234-5678-1234-567812345678")
-            >>> tileset.delete_layer_tileset(layer_type=TilesetLayerType.Vector, layer_uuid="12345678-1234-5678-1234-567812345678")
+            >>> layer = client.get_vector(uuid="12345678-1234-5678-1234-567812345678")
+            >>> tileset.delete_layer(layer)
         """
+        if type(layer) == VectorLayer:
+            layer_type = 'vector'
+
+        elif type(layer) == VectorLayerView:
+            layer_type = 'view'
+
+        else:
+            raise ValueError("layer input must be either 'VectorLayer' or 'VetorLayerview' object")
+
         data = {
-            "layer_type": layer_type.value,
-            "layer_uuid": layer_uuid
+            "layer_type": layer_type,
+            "layer_uuid": layer.uuid
         }
 
         endpoint = urljoin(self.endpoint, 'layers/')

{geobox-1.3.2 → geobox-1.3.3}/geobox.egg-info/PKG-INFO

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

{geobox-1.3.2 → geobox-1.3.3}/pyproject.toml

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

{geobox-1.3.2 → geobox-1.3.3}/tests/test_tileset.py

@@ -2,10 +2,12 @@ import pytest
 from urllib.parse import urljoin
 from unittest.mock import patch
 
-from geobox.tileset import Tileset, TilesetLayerType
+from geobox.tileset import Tileset
 from geobox.enums import LayerType
 from geobox.user import User
 from geobox.task import Task
+from geobox.vectorlayer import VectorLayer
+from geobox.view import VectorLayerView
 
 
 def test_init(api, mock_tileset_data):
@@ -35,15 +37,11 @@ def test_getattr(api, mock_tileset_data):
         _ = tileset.nonexistent_attribute
 
 
-def test_create_tileset(api, mock_tileset_data):
+def test_create_tileset(api, mock_tileset_data, mock_vector_data, mock_view_data):
     """Test creating a tileset"""
     api.post.return_value = mock_tileset_data
-    layers = [
-                 {
-                 "layer_type": "vector",
-                 "layer_uuid": "your_layer_uuid"
-                 }
-            ]
+    layers = [VectorLayer(api, uuid=mock_vector_data['uuid'], layer_type=LayerType.MultiPoint, data=mock_vector_data), 
+                VectorLayerView(api, uuid=mock_view_data['uuid'], layer_type=LayerType.MultiPoint, data=mock_view_data)]
     tileset = Tileset.create_tileset(api, 
                                         mock_tileset_data['name'], 
                                         layers=layers,
@@ -54,6 +52,13 @@ def test_create_tileset(api, mock_tileset_data):
     assert isinstance(tileset, Tileset)
     assert tileset.uuid == mock_tileset_data['uuid']
     assert tileset.data == mock_tileset_data
+    api.post.assert_called_once_with('tilesets/', {'name': mock_tileset_data['name'], 
+                                                    'min_zoom': mock_tileset_data['min_zoom'], 
+                                                    'max_zoom': mock_tileset_data['max_zoom'], 
+                                                    'layers': [{'layer_type': 'vector', 
+                                                                'layer_uuid': mock_vector_data['uuid']}, 
+                                                                {'layer_type': 'view', 
+                                                                'layer_uuid': mock_view_data['uuid']}]})
 
 
 def test_get_tilesets(api, mock_tileset_data):
@@ -133,43 +138,63 @@ def test_delete(api, mock_tileset_data):
         api.delete.assert_called_once_with(endpoint)
 
 
-def test_get_tileset_layers(api, mock_tileset_data, mock_vector_data):
+def test_get_layers(api, mock_tileset_data, mock_vector_data, mock_view_data):
     """Test getting tileset layers."""
     mock_layers = [
         mock_vector_data,
-        mock_vector_data
+        mock_view_data
     ]
     with patch.object(api, 'get', return_value=mock_layers):
         tileset = Tileset(api, uuid=mock_tileset_data['uuid'], data=mock_tileset_data)
-        layers = tileset.get_tileset_layers()
+        layers = tileset.get_layers()
         assert len(layers) == 2
-        assert all(layer.layer_type == LayerType.Polygon for layer in layers)
         assert layers[0].name == mock_vector_data['name']
-        assert layers[1].name == mock_vector_data['name']
+        assert type(layers[0]) == VectorLayer
+        assert layers[1].name == mock_view_data['name']
+        assert type(layers[1]) == VectorLayerView
+
     # return count
     with patch.object(api, 'get', return_value=10):
         tileset = Tileset(api, uuid=mock_tileset_data['uuid'], data=mock_tileset_data)
-        layer_count = tileset.get_tileset_layers(return_count=True)
+        layer_count = tileset.get_layers(return_count=True)
         assert layer_count == 10
         api.get.assert_called_once_with(f'{tileset.endpoint}layers/?f=json&return_count=True&skip=0&limit=10&shared=False')
 
 
-def test_add_layer(api, mock_tileset_data, mock_vector_data):
+def test_add_layer(api, mock_tileset_data, mock_vector_data, mock_view_data):
     """Test adding layer to tileset."""
     with patch.object(api, 'post'):
         tileset = Tileset(api, uuid=mock_tileset_data['uuid'], data=mock_tileset_data)
-        tileset.add_layer(layer_type=TilesetLayerType.Vector, layer_uuid=mock_vector_data['uuid'])
+        layer = VectorLayer(api, uuid=mock_vector_data['uuid'], layer_type=LayerType.MultiPoint, data=mock_vector_data)
+        view = VectorLayerView(api, uuid=mock_view_data['uuid'], layer_type=LayerType.MultiPoint, data=mock_view_data)
+        tileset.add_layer(layer=layer)
         endpoint = urljoin(tileset.endpoint, 'layers/')
         api.post.assert_called_once_with(endpoint, {'layer_type': 'vector', 'layer_uuid': mock_vector_data['uuid']}, is_json=False)
+        api.post.reset_mock()
+        tileset.add_layer(layer=view)
+        api.post.assert_called_once_with(endpoint, {'layer_type': 'view', 'layer_uuid': mock_view_data['uuid']}, is_json=False)
+
+        # usupported input
+        with pytest.raises(ValueError):
+            tileset.add_layer(layer='')
 
 
-def test_delete_layer(api, mock_tileset_data, mock_vector_data):
+def test_delete_layer(api, mock_tileset_data, mock_vector_data, mock_view_data):
     """Test deleting layer from tileset."""
     with patch.object(api, 'delete'):
         tileset = Tileset(api, uuid=mock_tileset_data['uuid'], data=mock_tileset_data)
-        tileset.delete_layer(layer_type=TilesetLayerType.Vector, layer_uuid=mock_vector_data['uuid'])
+        layer = VectorLayer(api, uuid=mock_vector_data['uuid'], layer_type=LayerType.MultiPoint, data=mock_vector_data)
+        view = VectorLayerView(api, uuid=mock_view_data['uuid'], layer_type=LayerType.MultiPoint, data=mock_view_data)
+        tileset.delete_layer(layer=layer)
         endpoint = urljoin(tileset.endpoint, 'layers/')
         api.delete.assert_called_once_with(endpoint, {'layer_type': 'vector', 'layer_uuid': mock_vector_data['uuid']}, is_json=False)
+        api.delete.reset_mock()
+        tileset.delete_layer(layer=view)
+        api.delete.assert_called_once_with(endpoint, {'layer_type': 'view', 'layer_uuid': mock_view_data['uuid']}, is_json=False)
+
+        # usupported input
+        with pytest.raises(ValueError):
+            tileset.delete_layer(layer='')
 
 
 def test_share(api, mock_tileset_data, mock_user_data):