geobox 1.4.1__tar.gz → 1.4.2__tar.gz

{geobox-1.4.1 → geobox-1.4.2}/PKG-INFO

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

{geobox-1.4.1 → geobox-1.4.2}/geobox/map.py

@@ -574,11 +574,30 @@ class Map(Base):
             'view_settings': {},
             'toc_settings': []
         })
+    
+
+    def update_settings(self, settings: Dict) -> Dict:
+        """
+        Update the settings
+
+        settings (Dict): settings dictionary
+
+        Returns:
+            Dict: updated settings
+
+        Example:
+            >>> from geobox import GeoboxClient
+            >>> client = GeoboxClient()
+            >>> map1 = client.get_map(uuid="12345678-1234-5678-1234-567812345678")
+            >>> map2 = client.get_map(uuid="12345678-1234-5678-1234-567812345678")
+            >>> map1.update_settings(map2.settings)
+        """
+        return super()._set_settings(self.endpoint, settings)    
 
 
     def set_settings(self, **kwargs) -> Dict:
         """
-        Set the settings of the map.
+        Set the settings of the map using keywords
 
         Keyword Args:
             map_unit (str): 'latlng' | 'utm'.
@@ -736,7 +755,7 @@ class Map(Base):
         if not response or json:
             return response
         else:
-            return [Model(self.api, model['obj'], model) for model in response['objects']]
+            return [Model(self.api, model['obj'], model) for model in response['objects'] if response.get('objects')]
     
 
     def set_models(self, data: Dict) -> List['Model']:
@@ -771,7 +790,7 @@ class Map(Base):
         """
         endpoint = urljoin(self.endpoint, 'models/')
         response = self.api.put(endpoint, data)
-        return [Model(self.api, model['obj'], model) for model in response['objects']]
+        return [Model(self.api, model['obj'], model) for model in response['objects'] if response.get('objects')]
 
 
     def add_model(self, 

{geobox-1.4.1 → geobox-1.4.2}/geobox/model3d.py

@@ -1,5 +1,10 @@
 from typing import Dict, List, Optional, Optional, Union, TYPE_CHECKING
 from urllib.parse import urljoin, urlencode
+import os
+import zipfile
+import sys
+import requests
+import mimetypes
 
 from .base import Base
 from .exception import ApiRequestError
@@ -216,33 +221,113 @@ class Model(Base):
         super().delete(self.endpoint)
 
 
-    def get_content(self) -> bytes:
+    def _get_save_path(self, save_path: str = None) -> str:
         """
-        Get the raw content of the 3D model.
+        Get the path where the file should be saved.
+
+        Args:
+            save_path (str, optional): The path to save the file.
 
         Returns:
-            bytes: The raw content of the 3D model in glTF format.
+            str: The path where the file is saved.
+        
+        Raises:
+            ValueError: If save_path does not end with a '/'.
+
+        Example:
+            >>> from geobox import GeoboxClient
+            >>> from geobox.file import File
+            >>> from geobox import GeoboxClient
+            >>> client = GeoboxClient()
+            >>> file_path = File.get_file(client, uuid="12345678-1234-5678-1234-567812345678")
+        """
+        # If save_path is provided, check if it ends with a '/'
+        if save_path and save_path.endswith('/'):
+            return f'{save_path}'
+        
+        if save_path and not save_path.endswith('/'):
+            raise ValueError("save_path must end with a '/'")
+        
+        return os.getcwd()
+
+
+    def _create_progress_bar(self) -> 'tqdm':
+        """Creates a progress bar for the task."""
+        try:
+            from tqdm.auto import tqdm
+        except ImportError:
+            from .api import logger
+            logger.warning("[tqdm] extra is required to show the progress bar. install with: pip insatll geobox[tqdm]")
+            return None
+
+        return tqdm(unit="B", 
+                        total=int(self.size), 
+                        file=sys.stdout,
+                        dynamic_ncols=True,
+                        desc="Downloading",
+                        unit_scale=True,
+                        unit_divisor=1024, 
+                        ascii=True
+                )
+
+
+    def download(self, save_path: str = None, progress_bar: bool = True) -> str:
+        """
+        Download the 3D model, save it as a .glb file, zip it, and return the zip file path.
+
+        Args:
+            save_path (str, optional): Directory where the file should be saved.
+            progress_bar (bool, optional): Whether to show a progress bar. Default: True
+
+        Returns:
+            str: Path to the .zip file containing the .glb model.
 
         Raises:
             ApiRequestError: If the API request fails.
 
         Example:
             >>> from geobox import GeoboxClient
-            >>> from geobox.model3d import Model
             >>> client = GeoboxClient()
-            >>> model = Model.get_model(api=client, uuid="12345678-1234-5678-1234-567812345678")
-            >>> content = model.get_content()
-            >>> # Save the content to a file
-            >>> with open('model.gltf', 'wb') as f:
-            ...     f.write(content)
+            >>> model = client.get_models()[0]
+            >>> model.get_content()
         """
-        endpoint = urljoin(self.api.base_url, f'{self.endpoint}/content/')
-        response = self.api.session.get(endpoint)
-        
-        if response.status_code != 200:
-            raise ApiRequestError(f"Failed to get model content: {response.status_code}")
-            
-        return response.content
+        if not self.uuid:
+            raise ValueError("Model UUID is required to download content")
+
+        if self.data.get('obj'):
+            model = self.api.get_model(self.obj)
+        else:
+            model = self
+
+        save_path = model._get_save_path(save_path)
+        os.makedirs(save_path, exist_ok=True)
+
+        endpoint = urljoin(model.api.base_url, f"{model.endpoint}/content/")
+        with model.api.session.get(endpoint, stream=True) as response:
+            if response.status_code != 200:
+                raise ApiRequestError(f"Failed to get model content: {response.status_code}")
+
+            glb_filename = f"{model.name}.glb"
+            glb_path = os.path.join(save_path, glb_filename)
+
+            with open(glb_path, "wb") as f:
+                pbar = model._create_progress_bar() if progress_bar else None
+                for chunk in response.iter_content(chunk_size=8192):
+                    f.write(chunk)
+                    if pbar:
+                        pbar.update(len(chunk))
+                        pbar.refresh()
+                if pbar:
+                    pbar.close()
+
+        zip_filename = f"{model.name}.zip"
+        zip_path = os.path.join(save_path, zip_filename)
+        with zipfile.ZipFile(zip_path, "w", zipfile.ZIP_DEFLATED) as zipf:
+            zipf.write(glb_path, arcname=os.path.basename(glb_path))
+
+        os.remove(glb_path)
+
+        return os.path.abspath(zip_path)
 
 
     @property

{geobox-1.4.1 → geobox-1.4.2}/geobox/mosaic.py

@@ -401,6 +401,25 @@ class Mosaic(Raster):
         """
         return super().settings
     
+
+    def update_settings(self, settings: Dict) -> Dict:
+        """
+        Update the settings
+
+        settings (Dict): settings dictionary
+
+        Returns:
+            Dict: updated settings
+
+        Example:
+            >>> from geobox import GeoboxClient
+            >>> client = GeoboxClient()
+            >>> mosaic1 = client.get_mosaic(uuid="12345678-1234-5678-1234-567812345678")
+            >>> mosaic2 = client.get_mosaic(uuid="12345678-1234-5678-1234-567812345678")
+            >>> mosaic1.update_settings(mosaic2.settings)
+        """
+        return super().update_settings(settings)  
+    
     
     def set_settings(self, **kwargs) -> None:
         """

{geobox-1.4.1 → geobox-1.4.2}/geobox/query.py

@@ -179,7 +179,7 @@ class Query(Base):
 
 
     @classmethod
-    def create_query(cls, api: 'GeoboxClient', name: str, display_name: str = None, sql: str = None, params: List = None) -> 'Query':
+    def create_query(cls, api: 'GeoboxClient', name: str, display_name: str = None, description:str = None, sql: str = None, params: List = None) -> 'Query':
         """
         Creates a new query.
 
@@ -187,6 +187,7 @@ class Query(Base):
             api (Api): The GeoboxClient instance for making requests.
             name (str): The name of the query.
             display_name (str, optional): The display name of the query.
+            description (str, optional): The description of the query.
             sql (str, optional): The SQL statement for the query.
             params (list, optional): The parameters for the SQL statement.
 
@@ -204,6 +205,7 @@ class Query(Base):
         data = {
             "name": name,
             "display_name": display_name,
+            "description": description,
             "sql": sql,
             "params": params
         }

{geobox-1.4.1 → geobox-1.4.2}/geobox/raster.py

@@ -641,6 +641,25 @@ class Raster(Base):
             >>> raster.settings
         """
         return super()._get_settings(self.endpoint)
+    
+
+    def update_settings(self, settings: Dict) -> Dict:
+        """
+        Update the settings
+
+        settings (Dict): settings dictionary
+
+        Returns:
+            Dict: updated settings
+
+        Example:
+            >>> from geobox import GeoboxClient
+            >>> client = GeoboxClient()
+            >>> raster1 = client.get_raster(uuid="12345678-1234-5678-1234-567812345678")
+            >>> raster2 = client.get_raster(uuid="12345678-1234-5678-1234-567812345678")
+            >>> raster1.update_settings(raster2.settings)
+        """
+        return super()._set_settings(self.endpoint, settings)  
 
 
     def set_settings(self, **kwargs) -> None:

{geobox-1.4.1 → geobox-1.4.2}/geobox/vectorlayer.py

@@ -1062,6 +1062,25 @@ class VectorLayer(Base):
             >>> setting = layer.setting
         """
         return super()._get_settings(endpoint=self.endpoint)
+    
+
+    def update_settings(self, settings: Dict) -> Dict:
+        """
+        Update the settings
+
+        settings (Dict): settings dictionary
+
+        Returns:
+            Dict: updated settings
+
+        Example:
+            >>> from geobox import GeoboxClient
+            >>> client = GeoboxClient()
+            >>> layer1 = client.get_vector(uuid="12345678-1234-5678-1234-567812345678")
+            >>> layer2 = client.get_vector(uuid="12345678-1234-5678-1234-567812345678")
+            >>> layer1.update_settings(layer2.settings)
+        """
+        return super()._set_settings(self.endpoint, settings)  
 
 
     def set_settings(self, **kwargs) -> Dict:

{geobox-1.4.1 → geobox-1.4.2}/geobox/view.py

@@ -722,6 +722,25 @@ class VectorLayerView(VectorLayer):
         return super().settings
 
 
+    def update_settings(self, settings: Dict) -> Dict:
+        """
+        Update the settings
+
+        settings (Dict): settings dictionary
+
+        Returns:
+            Dict: updated settings
+
+        Example:
+            >>> from geobox import GeoboxClient
+            >>> client = GeoboxClient()
+            >>> view1 = client.get_view(uuid="12345678-1234-5678-1234-567812345678")
+            >>> view2 = client.get_view(uuid="12345678-1234-5678-1234-567812345678")
+            >>> view1.update_settings(view2.settings)
+        """
+        return super().update_settings(settings) 
+
+
     def set_settings(self, **kwargs) -> Dict:
         """
         Set the settings of the Vector Layer.

{geobox-1.4.1 → geobox-1.4.2}/geobox.egg-info/PKG-INFO

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

{geobox-1.4.1 → geobox-1.4.2}/pyproject.toml

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

{geobox-1.4.1 → geobox-1.4.2}/tests/test_map.py

@@ -302,6 +302,15 @@ def test_settings(api, mock_map_data):
     assert settings == mock_map_data['settings']
 
 
+def test_update_settings(api, mock_map_data):
+    map1 = Map(api, uuid=mock_map_data['uuid'], data=mock_map_data)
+    map2 = Map(api, uuid=mock_map_data['uuid'], data=mock_map_data)
+    settings = map2.settings
+    api.put.return_value = settings
+    map1.update_settings(map2.settings)
+    api.put.assert_called_once_with(f'{map1.endpoint}settings/', settings)
+
+
 def test_set_settings(api, mock_map_data):
     map = Map(api, uuid=mock_map_data['uuid'], data=mock_map_data)
     settings = map.settings

{geobox-1.4.1 → geobox-1.4.2}/tests/test_model3d.py

@@ -131,25 +131,161 @@ def test_delete(api, mock_model_data):
     api.delete.assert_called_once_with(endpoint)
 
 
-def test_get_content(api, mock_model_data):
+import os
+import pytest
+from unittest.mock import MagicMock, patch
+from geobox.file import File
+
+
+def test_get_save_path_variants(api, mock_model_data, tmp_path):
+    """Test _get_save_path edge cases."""
     model = Model(api, uuid=mock_model_data['uuid'], data=mock_model_data)
-    
+
+    # Case: no save_path -> returns cwd
+    result = model._get_save_path()
+    assert result == os.getcwd()
+
+    # Case: save_path ends with '/' -> returns unchanged
+    path = str(tmp_path) + "/"
+    assert model._get_save_path(save_path=path) == path
+
+    # Case: save_path does NOT end with '/' -> raises ValueError
+    path_invalid = str(tmp_path)
+    with pytest.raises(ValueError, match="save_path must end with a '/'"):
+        model._get_save_path(save_path=path_invalid)
+
+
+def test_create_progress_bar_import_error(api, mock_model_data):
+    """Test _create_progress_bar when tqdm is missing."""
+    model = Model(api, uuid=mock_model_data['uuid'], data=mock_model_data)
+    model.size = 1234
+
+    import builtins
+    original_import = builtins.__import__
+
+    def mocked_import(name, *args, **kwargs):
+        if name == "tqdm.auto":
+            raise ImportError("No module named 'tqdm'")
+        return original_import(name, *args, **kwargs)
+
+    with patch("builtins.__import__", side_effect=mocked_import):
+        with patch("geobox.api.logger") as mock_logger:
+            pbar = model._create_progress_bar()
+            assert pbar is None
+            mock_logger.warning.assert_called_once()
+
+
+def test_download_with_obj(api, mock_model_data, tmp_path):
+    """Test download() when self.data['obj'] exists."""
+    # Make mock data have 'obj'
+    mock_model_data['obj'] = "object-id"
+    model = Model(api, uuid=mock_model_data['uuid'], data=mock_model_data)
+    model.name = "test_model"
+    model.endpoint = "models"
+
+    # Mock api.get_model() to return a model with a normal download
+    downloaded_model = MagicMock()
+    downloaded_model.api = api
+    downloaded_model.name = model.name
+    downloaded_model.endpoint = model.endpoint
+    downloaded_model.data = {}
+    downloaded_model._get_save_path = lambda sp: str(tmp_path) + "/"
+    downloaded_model._create_progress_bar = lambda: MagicMock()
+
+    api.get_model.return_value = downloaded_model
+
+    # Mock API response
     mock_response = MagicMock()
-    mock_response.status_code = 200
-    mock_response.content = b'test content'
-    
-    api.session = MagicMock()
-    api.session.get.return_value = mock_response
-    
-    content = model.get_content()
-    
-    api.session.get.assert_called_once_with(f"{model.api.base_url}{model.endpoint}content/")
-    
-    assert content == b'test content'
+    mock_response.__enter__.return_value.iter_content.return_value = [b"chunk"]
+    mock_response.__enter__.return_value.status_code = 200
+    mock_response.__exit__.return_value = None
+
+    with patch.object(api.session, "get", return_value=mock_response), \
+         patch("builtins.open", MagicMock()), \
+         patch("os.makedirs", return_value=None), \
+         patch("os.remove", return_value=None), \
+         patch("zipfile.ZipFile", MagicMock()):
+        zip_path = model.download()
+        assert zip_path.endswith(".zip")
+
+
+def test_download_non_200(api, mock_model_data, tmp_path):
+    """Test download() raises ApiRequestError on bad status code."""
+    model = Model(api, uuid=mock_model_data['uuid'], data=mock_model_data)
+    model.name = "test_model"
+    model.endpoint = "models"
+
+    mock_response = MagicMock()
+    mock_response.__enter__.return_value.status_code = 404
+    mock_response.__enter__.return_value.iter_content.return_value = []
+    mock_response.__exit__.return_value = None
+
+    with patch.object(api.session, "get", return_value=mock_response), \
+         patch("os.makedirs", return_value=None):
+        from geobox.api import ApiRequestError
+        with pytest.raises(ApiRequestError, match="Failed to get model content: 404"):
+            model.download(save_path=str(tmp_path)+"/")
+
+
+def test_download_missing_uuid(api, mock_model_data):
+    """Raise ValueError if UUID is missing."""
+    model = Model(api, uuid=None, data=mock_model_data)  # uuid is None
+    model.name = "test_model"
+    model.endpoint = "models"
+
+    from geobox.api import ApiRequestError
 
-    mock_response.status_code = 404
-    with pytest.raises(ApiRequestError):
-        content = model.get_content()
+    with pytest.raises(ValueError, match="Model UUID is required to download content"):
+        model.download()
+
+
+def test_create_progress_bar_normal(api, mock_model_data):
+    """Test _create_progress_bar returns tqdm instance when tqdm is available."""
+    from tqdm.auto import tqdm
+
+    model = Model(api, uuid=mock_model_data['uuid'], data=mock_model_data)
+    model.size = 1024  # required for total=int(self.size)
+
+    pbar = model._create_progress_bar()
+    assert isinstance(pbar, tqdm)
+    assert pbar.total == 1024
+
+
+# def test_download_method_simple(api, mock_model_data, tmp_path):
+#     """Test File.download() method without manually setting headers."""
+#     model = Model(api, uuid=mock_model_data['uuid'], data=mock_model_data)
+#     model.name = "test_model"  # ensure a name for filenames
+#     model.endpoint = "models"
+
+#     # Mock API response
+#     mock_response = MagicMock()
+#     mock_response.__enter__.return_value.iter_content.return_value = [b"chunk1", b"chunk2"]
+#     mock_response.__enter__.return_value.status_code = 200
+#     mock_response.__exit__.return_value = None
+
+#     # Patch all filesystem and network operations
+#     with patch.object(api.session, "get", return_value=mock_response), \
+#          patch("builtins.open", new_callable=MagicMock), \
+#          patch("os.makedirs", return_value=None), \
+#          patch("os.remove", return_value=None), \
+#          patch("zipfile.ZipFile") as mock_zip, \
+#          patch.object(model, "_create_progress_bar", return_value=MagicMock()) as mock_pbar:
+
+#         # Save to custom tmp_path
+#         save_dir = str(tmp_path) + "/"
+#         zip_path = model.download(save_path=save_dir)
+
+#         # Assertions
+#         assert zip_path.endswith(".zip")
+#         assert os.path.commonpath([zip_path, save_dir]) == os.path.normpath(save_dir)
+#         assert os.path.basename(zip_path) == "test_model.zip"
+#         mock_zip.assert_called_once()  # ensure zipfile was called
+#         mock_pbar.return_value.update.assert_called()  # ensure progress bar updated
+
+#     # Test that ValueError is raised if uuid is missing
+#     model.uuid = None
+#     with pytest.raises(ValueError, match="Model UUID is required to download content"):
+#         model.download(save_path=save_dir)
         
 
 def test_thumbnail(api, mock_model_data):

{geobox-1.4.1 → geobox-1.4.2}/tests/test_mosaic.py

@@ -184,6 +184,15 @@ def test_settings(api, mock_mosaic_data):
     assert settings == {'value': 'test'}
 
 
+def test_update_settings(api, mock_mosaic_data):
+    mosaic1 = Mosaic(api, uuid=mock_mosaic_data['uuid'], data=mock_mosaic_data)
+    mosaic2 = Mosaic(api, uuid=mock_mosaic_data['uuid'], data=mock_mosaic_data)
+    settings = mosaic2.settings
+    api.put.return_value = settings
+    mosaic1.update_settings(mosaic2.settings)
+    api.put.assert_called_once_with(f'{mosaic1.endpoint}settings/', settings)
+
+
 def test_set_settings(api, mock_mosaic_data):
     """Test the set_settings method."""
     mosaic = Mosaic(api, mock_mosaic_data['uuid'], mock_mosaic_data)

{geobox-1.4.1 → geobox-1.4.2}/tests/test_raster.py

@@ -310,6 +310,15 @@ def test_settings(api, mock_raster_data):
     api.get.assert_called_once_with(f'{raster.endpoint}settings/?f=json')
 
 
+def test_update_settings(api, mock_raster_data):
+    raster1 = Raster(api, uuid=mock_raster_data['uuid'], data=mock_raster_data)
+    raster2 = Raster(api, uuid=mock_raster_data['uuid'], data=mock_raster_data)
+    settings = raster2.settings
+    api.put.return_value = settings
+    raster1.update_settings(raster2.settings)
+    api.put.assert_called_once_with(f'{raster1.endpoint}settings/', settings)
+
+
 def test_set_settings(api, mock_raster_data):
     """Test setting raster settings."""
     raster = Raster(api, uuid=mock_raster_data['uuid'], data=mock_raster_data)

{geobox-1.4.1 → geobox-1.4.2}/tests/test_vectorlayer.py

@@ -625,6 +625,16 @@ def test_settings(api, mock_vector_data, layer_type):
     assert settings == {'settings': 'value'}
 
 
+@pytest.mark.parametrize("layer_type", [type for type in LayerType])
+def test_update_settings(api, mock_vector_data, layer_type):
+    layer1 = VectorLayer(api, uuid=mock_vector_data['uuid'], data=mock_vector_data, layer_type=layer_type)
+    layer2 = VectorLayer(api, uuid=mock_vector_data['uuid'], data=mock_vector_data, layer_type=layer_type)
+    settings = layer2.settings
+    api.put.return_value = settings
+    layer1.update_settings(layer2.settings)
+    api.put.assert_called_once_with(f'{layer1.endpoint}settings/', settings)
+
+
 @pytest.mark.parametrize("layer_type", [type for type in LayerType])
 def test_set_settings(api, mock_vector_data, layer_type):
     """Test setting the settings of a layer."""

{geobox-1.4.1 → geobox-1.4.2}/tests/test_view.py

@@ -563,6 +563,16 @@ def test_settings(api, mock_view_data, layer_type):
     assert settings == {'settings': 'value'}
 
 
+@pytest.mark.parametrize("layer_type", [type for type in LayerType])
+def test_update_settings(api, mock_view_data, layer_type):
+    view1 = VectorLayerView(api, uuid=mock_view_data['uuid'], data=mock_view_data, layer_type=layer_type)
+    view2 = VectorLayerView(api, uuid=mock_view_data['uuid'], data=mock_view_data, layer_type=layer_type)
+    settings = view2.settings
+    api.put.return_value = settings
+    view1.update_settings(view2.settings)
+    api.put.assert_called_once_with(f'{view1.endpoint}settings/', settings)
+
+
 @pytest.mark.parametrize("layer_type", [type for type in LayerType])
 def test_set_settings(api, mock_view_data, layer_type):
     """Test setting the settings of a layer."""