geobox 1.4.1__py3-none-any.whl → 2.0.0__py3-none-any.whl

geobox/model3d.py

@@ -1,17 +1,22 @@
 from typing import Dict, List, Optional, Optional, Union, TYPE_CHECKING
 from urllib.parse import urljoin, urlencode
+import os
+import zipfile
+import sys
 
 from .base import Base
 from .exception import ApiRequestError
+from .utils import get_save_path
 
 if TYPE_CHECKING:
     from . import GeoboxClient
     from .user import User
+    from .aio import AsyncGeoboxClient
+    from .aio.model3d import Model as AsyncModel
+
 
 class Model(Base):
-    """
-    A class representing a 3D model in Geobox.
-    """
+
     BASE_ENDPOINT = '3dmodels/'
 
     def __init__(self, 
@@ -216,33 +221,83 @@ class Model(Base):
         super().delete(self.endpoint)
 
 
-    def get_content(self) -> bytes:
+    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:
         """
-        Get the raw content of the 3D model.
+        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:
-            bytes: The raw content of the 3D model in glTF format.
+            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.download()
         """
-        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 = 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
@@ -330,3 +385,27 @@ class Model(Base):
             'limit': limit
         }
         return super()._get_shared_users(self.endpoint, params)
+
+
+    def to_async(self, async_client: 'AsyncGeoboxClient') -> 'AsyncModel':
+        """
+        Switch to async version of the 3d model instance to have access to the async methods
+
+        Args:
+            async_client (AsyncGeoboxClient): The async version of the GeoboxClient instance for making requests.
+
+        Returns:
+            geobox.aio.model3d.Model: the async instance of the 3d model.
+
+        Example:
+            >>> from geobox import Geoboxclient
+            >>> from geobox.aio import AsyncGeoboxClient
+            >>> from geobox.model3d import Model
+            >>> client = GeoboxClient()
+            >>> model = Model.get_model(client, uuid="12345678-1234-5678-1234-567812345678")
+            >>> async with AsyncGeoboxClient() as async_client:
+            >>>     async_model = model.to_async(async_client)
+        """
+        from .aio.model3d import Model as AsyncModel
+
+        return AsyncModel(api=async_client, uuid=self.uuid, data=self.data)

geobox/mosaic.py

@@ -8,15 +8,12 @@ if TYPE_CHECKING:
     from . import GeoboxClient
     from .user import User
     from .task import Task
+    from .aio import AsyncGeoboxClient
+    from .aio.mosaic import Mosaic as AsyncMosaic
+
 
 class Mosaic(Raster):
-    """
-    A class to represent a Mosaic in Geobox.
 
-    This class provides methods to interact with the mosaic in Geobox.
-    It inherits from the Raster class and provides additional methods to interact with the mosaic.
-    It also provides properties to access the mosaic data, and a method to update the mosaic.
-    """
     BASE_ENDPOINT: str = 'mosaics/'
 
     def __init__(self, 
@@ -227,7 +224,7 @@ class Mosaic(Raster):
             >>> from geobox.mosaic import Mosaic
             >>> client = GeoboxClient()
             >>> mosaic = Mosaic.get_mosaic(client, uuid="12345678-1234-5678-1234-567812345678")
-            >>> mosaic.update_mosaic(name='new_name', display_name='new_display_name', description='new_description', pixel_selection='new_pixel_selection', min_zoom=10)
+            >>> mosaic.update(name='new_name', display_name='new_display_name', description='new_description', pixel_selection='new_pixel_selection', min_zoom=10)
         """
         data = {
             'name': kwargs.get('name'),
@@ -401,6 +398,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:
         """
@@ -654,3 +670,27 @@ class Mosaic(Raster):
             >>> mosaic.cache_size
         """
         return super().cache_size
+    
+
+    def to_async(self, async_client: 'AsyncGeoboxClient') -> 'AsyncMosaic':
+        """
+        Switch to async version of the mosaic instance to have access to the async methods
+
+        Args:
+            async_client (AsyncGeoboxClient): The async version of the GeoboxClient instance for making requests.
+
+        Returns:
+            geobox.aio.mosaic.Mosaic: the async instance of the mosaic.
+
+        Example:
+            >>> from geobox import Geoboxclient
+            >>> from geobox.aio import AsyncGeoboxClient
+            >>> from geobox.mosaic import Mosaic
+            >>> client = GeoboxClient()
+            >>> mosaic = Mosaic.get_mosaic(client, uuid="12345678-1234-5678-1234-567812345678")
+            >>> async with AsyncGeoboxClient() as async_client:
+            >>>     async_mosaic = mosaic.to_async(async_client)
+        """
+        from .aio.mosaic import Mosaic as AsyncMosaic
+
+        return AsyncMosaic(api=async_client, uuid=self.uuid, data=self.data)

geobox/plan.py

@@ -5,6 +5,8 @@ from .base import Base
 
 if TYPE_CHECKING:
     from . import GeoboxClient
+    from .aio import AsyncGeoboxClient
+    from .aio.plan import Plan as AsyncPlan
 
 class Plan(Base):
 
@@ -209,7 +211,7 @@ class Plan(Base):
             >>> from geobox import GeoboxClient
             >>> from geobox.plan import Plan
             >>> client = GeoboxClient()
-            >>> plan = Workflow.get_plan_by_name(client, name='test')
+            >>> plan = Plan.get_plan_by_name(client, name='test')
             or
             >>> plan = client.get_plan_by_name(name='test')
         """
@@ -250,7 +252,7 @@ class Plan(Base):
             >>> from geobox.plan import Plan
             >>> client = GeoboxClient()
             >>> plan = Plan.get_plan(client, plan_id=1)
-            >>> plan.update_plan(display_name="New Display Name")
+            >>> plan.update(display_name="New Display Name")
         """
         data = {
             "name": kwargs.get('name'),
@@ -285,4 +287,28 @@ class Plan(Base):
             >>> plan.delete()
         """
         super().delete(self.endpoint)
-        self.plan_id = None
+        self.plan_id = None
+
+
+    def to_async(self, async_client: 'AsyncGeoboxClient') -> 'AsyncPlan':
+        """
+        Switch to async version of the plan instance to have access to the async methods
+
+        Args:
+            async_client (AsyncGeoboxClient): The async version of the GeoboxClient instance for making requests.
+
+        Returns:
+            geobox.aio.plan.Plan: the async instance of the plan.
+
+        Example:
+            >>> from geobox import Geoboxclient
+            >>> from geobox.aio import AsyncGeoboxClient
+            >>> from geobox.plan import Plan
+            >>> client = GeoboxClient()
+            >>> plan = Plan.get_plan(client, plan_id=1)
+            >>> async with AsyncGeoboxClient() as async_client:
+            >>>     async_plan = plan.to_async(async_client)
+        """
+        from .aio.plan import Plan as AsyncPlan
+
+        return AsyncPlan(api=async_client, plan_id=self.plan_id, data=self.data)

geobox/query.py

@@ -9,11 +9,11 @@ from .enums import QueryResultType, QueryGeometryType, QueryParamType
 if TYPE_CHECKING:
     from . import GeoboxClient
     from .user import User
+    from .aio import AsyncGeoboxClient
+    from .aio.query import Query as AsyncQuery
 
 class Query(Base):
-    """
-    A class to interact with queries in GeoBox.
-    """
+
     BASE_ENDPOINT: str = 'queries/'
 
     def __init__(self, 
@@ -83,6 +83,7 @@ class Query(Base):
             >>> client = GeoboxClient()
             >>> query = Query.get_query(client, uuid="12345678-1234-5678-1234-567812345678")
             >>> query.sql = 'SELECT * FROM some_layer'
+            >>> query.save()
         """
         self.data['sql'] = value
 
@@ -126,6 +127,7 @@ class Query(Base):
             >>> client = GeoboxClient()
             >>> query = Query.get_query(client, uuid="12345678-1234-5678-1234-567812345678")
             >>> query.params = [{'name': 'layer', 'value': '12345678-1234-5678-1234-567812345678', 'type': 'Layer'}]
+            >>> query.save()
         """
         if not isinstance(self.data.get('params'), list):
             self.data['params'] = []
@@ -179,7 +181,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 +189,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 +207,7 @@ class Query(Base):
         data = {
             "name": name,
             "display_name": display_name,
+            "description": description,
             "sql": sql,
             "params": params
         }
@@ -342,6 +346,7 @@ class Query(Base):
             or
             >>> query = client.get_query(uuid="12345678-1234-5678-1234-567812345678")
             >>> query.add_param(name='param_name', value='param_value', type=QueryParamType.LAYER)
+            >>> query.save()
         """
         self._check_access()
         
@@ -376,6 +381,7 @@ class Query(Base):
             or
             >>> query = client.get_query(uuid="12345678-1234-5678-1234-567812345678")
             >>> query.remove_param(name='param_name')
+            >>> query.save()
         """
         self._check_access()
         
@@ -497,7 +503,6 @@ class Query(Base):
             >>> from geobox.query import Query
             >>> client = GeoboxClient()
             >>> query = Query.get_query(client, uuid="12345678-1234-5678-1234-567812345678")
-            >>> query.sql = "SELECT * FROM some_layer"
             >>> query.save()
         """
         self.params = [item for item in self.params if item.get('value')]
@@ -618,6 +623,13 @@ class Query(Base):
 
         Returns:
             str: The thumbnail URL.
+
+        Example:
+            >>> from geobox import GeoboxClient
+            >>> from geobox.query import Query
+            >>> client = GeoboxClient()
+            >>> query = Query.get_query(client, uuid="12345678-1234-5678-1234-567812345678")
+            >>> query.thumbnail
         """
         self._check_access()
         return super().thumbnail()
@@ -663,3 +675,27 @@ class Query(Base):
         response = self.api.post(endpoint, data)
         task = Task.get_task(self.api, response.get('task_id'))
         return task
+
+
+    def to_async(self, async_client: 'AsyncGeoboxClient') -> 'AsyncQuery':
+        """
+        Switch to async version of the query instance to have access to the async methods
+
+        Args:
+            async_client (AsyncGeoboxClient): The async version of the GeoboxClient instance for making requests.
+
+        Returns:
+            geobox.aio.query.Query: the async instance of the query.
+
+        Example:
+            >>> from geobox import Geoboxclient
+            >>> from geobox.aio import AsyncGeoboxClient
+            >>> from geobox.query import Query
+            >>> client = GeoboxClient()
+            >>> query = Query.get_query(client, uuid="12345678-1234-5678-1234-567812345678")
+            >>> async with AsyncGeoboxClient() as async_client:
+            >>>     async_query = query.to_async(async_client)
+        """
+        from .aio.query import Query as AsyncQuery
+
+        return AsyncQuery(api=async_client, uuid=self.uuid, data=self.data)

geobox/raster.py

@@ -12,15 +12,11 @@ from .task import Task
 if TYPE_CHECKING:
     from . import GeoboxClient 
     from .user import User
+    from .aio import AsyncGeoboxClient
+    from .aio.raster import Raster as AsyncRaster
 
 class Raster(Base):
-    """
-    A class to represent a Raster in Geobox.
 
-    This class provides functionality to interact with rasters in Geobox.
-    It supports various operations including CRUD operations on rasters, as well as advanced operations like getting statistics, points, and tiles.
-    It also provides properties to access the raster data, and a method to download the raster.
-    """
     BASE_ENDPOINT: str = 'rasters/'
 
     def __init__(self,
@@ -322,13 +318,6 @@ class Raster(Base):
         
         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('/'):
@@ -641,6 +630,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:
@@ -829,3 +837,27 @@ class Raster(Base):
             >>> raster.cache_size
         """
         return super()._cache_size(self.endpoint)
+
+
+    def to_async(self, async_client: 'AsyncGeoboxClient') -> 'AsyncRaster':
+        """
+        Switch to async version of the raster instance to have access to the async methods
+
+        Args:
+            async_client (AsyncGeoboxClient): The async version of the GeoboxClient instance for making requests.
+
+        Returns:
+            geobox.aio.raster.Raster: the async instance of the raster.
+
+        Example:
+            >>> from geobox import Geoboxclient
+            >>> from geobox.aio import AsyncGeoboxClient
+            >>> from geobox.raster import Raster
+            >>> client = GeoboxClient()
+            >>> raster = Raster.get_raster(client, uuid="12345678-1234-5678-1234-567812345678")
+            >>> async with AsyncGeoboxClient() as async_client:
+            >>>     async_raster = raster.to_async(async_client)
+        """
+        from .aio.raster import Raster as AsyncRaster
+
+        return AsyncRaster(api=async_client, uuid=self.uuid, data=self.data)

geobox/scene.py

@@ -6,6 +6,8 @@ from .base import Base
 if TYPE_CHECKING:
     from . import GeoboxClient
     from .user import User 
+    from .aio import AsyncGeoboxClient
+    from .aio.scene import Scene as AsyncScene
 
 class Scene(Base):
 
@@ -314,3 +316,27 @@ class Scene(Base):
             'limit': limit
         }
         return super()._get_shared_users(self.endpoint, params)
+    
+
+    def to_async(self, async_client: 'AsyncGeoboxClient') -> 'AsyncScene':
+        """
+        Switch to async version of the scene instance to have access to the async methods
+
+        Args:
+            async_client (AsyncGeoboxClient): The async version of the GeoboxClient instance for making requests.
+
+        Returns:
+            geobox.aio.scene.Scene: the async instance of the scene.
+
+        Example:
+            >>> from geobox import Geoboxclient
+            >>> from geobox.aio import AsyncGeoboxClient
+            >>> from geobox.scene import Scene
+            >>> client = GeoboxClient()
+            >>> scene = Scene.get_scene(client, uuid="12345678-1234-5678-1234-567812345678")
+            >>> async with AsyncGeoboxClient() as async_client:
+            >>>     async_scene = scene.to_async(async_client)
+        """
+        from .aio.scene import Scene as AsyncScene
+
+        return AsyncScene(api=async_client, uuid=self.uuid, data=self.data)

geobox/settings.py

@@ -8,6 +8,9 @@ from .enums import MaxLogPolicy, InvalidDataPolicy, LoginFailurePolicy, MaxConcu
 
 if TYPE_CHECKING:
     from . import GeoboxClient
+    from .aio import AsyncGeoboxClient
+    from .aio.settings import SystemSettings as AsyncSystemSettings
+
 
 class SystemSettings(Base):
 
@@ -163,4 +166,30 @@ class SystemSettings(Base):
             "blocked_ip_addresses": kwargs.get('blocked_ip_addresses'),
             
         }
-        return super()._update(self.BASE_ENDPOINT, data)
+        return super()._update(self.BASE_ENDPOINT, data)
+    
+
+    def to_async(self, async_client: 'AsyncGeoboxClient') -> 'AsyncSystemSettings':
+        """
+        Switch to async version of the system settings instance to have access to the async methods
+
+        Args:
+            async_client (AsyncGeoboxClient): The async version of the GeoboxClient instance for making requests.
+
+        Returns:
+            geobox.aio.settings.SystemSettings: the async instance of the system settings.
+
+        Example:
+            >>> from geobox import Geoboxclient
+            >>> from geobox.aio import AsyncGeoboxClient
+            >>> from geobox.setting import SystemSettings
+            >>> client = GeoboxClient()
+            >>> settings = SystemSetting.get_system_settings(client)
+            or
+            >>> settings = client.get_system_settings()
+            >>> async with AsyncGeoboxClient() as async_client:
+            >>>     async_settings = settings.to_async(async_client)
+        """
+        from .aio.settings import SystemSettings as AsyncSystemSettings
+
+        return AsyncSystemSettings(api=async_client, data=self.data)

geobox/task.py

@@ -12,15 +12,12 @@ if TYPE_CHECKING:
     from .model3d import Model
     from .file import File
     from .tile3d import Tile3d
+    from .aio import AsyncGeoboxClient
+    from .aio.task import Task as AsyncTask
+
 
 class Task(Base):
-    """
-    A class to represent a task in Geobox.
 
-    This class provides functionality to interact with tasks in Geobox.
-    It supports various operations including getting tasks, as well as advanced operations like waiting for a task to finish.
-    It also provides properties to access the task data, and a method to abort the task.
-    """
     BASE_ENDPOINT: str = 'tasks/'
 
     def __init__(self, 
@@ -377,3 +374,28 @@ class Task(Base):
         """
         return super()._get_detail(api, cls.BASE_ENDPOINT, uuid, factory_func=lambda api, item: Task(api, item['uuid'], item))
 
+
+    def to_async(self, async_client: 'AsyncGeoboxClient') -> 'AsyncTask':
+        """
+        Switch to async version of the task instance to have access to the async methods
+
+        Args:
+            async_client (AsyncGeoboxClient): The async version of the GeoboxClient instance for making requests.
+
+        Returns:
+            geobox.aio.task.Task: the async instance of the task.
+
+        Example:
+            >>> from geobox import Geoboxclient
+            >>> from geobox.aio import AsyncGeoboxClient
+            >>> from geobox.task import Task
+            >>> client = GeoboxClient()
+            >>> task = Task.get_task(client, uuid="12345678-1234-5678-1234-567812345678")
+            or
+            >>> task = client.get_task(uuid="12345678-1234-5678-1234-567812345678")
+            >>> async with AsyncGeoboxClient() as async_client:
+            >>>     async_task = task.to_async(async_client)
+        """
+        from .aio.task import Task as AsyncTask
+
+        return AsyncTask(api=async_client, uuid=self.uuid, data=self.data)

geobox/tile3d.py

@@ -6,6 +6,8 @@ from .base import Base
 if TYPE_CHECKING:
     from . import GeoboxClient
     from .user import User
+    from .aio import AsyncGeoboxClient
+    from .aio.tile3d import Tile3d as AsyncTile3d
 
 
 class Tile3d(Base):
@@ -310,4 +312,28 @@ class Tile3d(Base):
             >>> tile_json = tile.get_tileset_json()
         """
         endpoint = urljoin(self.endpoint, 'tileset.json') 
-        return self.api.get(endpoint)
+        return self.api.get(endpoint)
+    
+
+    def to_async(self, async_client: 'AsyncGeoboxClient') -> 'AsyncTile3d':
+        """
+        Switch to async version of the 3d tile instance to have access to the async methods
+
+        Args:
+            async_client (AsyncGeoboxClient): The async version of the GeoboxClient instance for making requests.
+
+        Returns:
+            geobox.aio.tile3d.Tile3d: the async instance of the 3d tile.
+
+        Example:
+            >>> from geobox import Geoboxclient
+            >>> from geobox.aio import AsyncGeoboxClient
+            >>> from geobox.tile3d import Tile3d
+            >>> client = GeoboxClient()
+            >>> tile = Tile3d.get_3dtile(api=client, uuid="12345678-1234-5678-1234-567812345678")
+            >>> async with AsyncGeoboxClient() as async_client:
+            >>>     async_tile = tile.to_async(async_client)
+        """
+        from .aio.tile3d import Tile3d as AsyncTile3d
+
+        return AsyncTile3d(api=async_client, uuid=self.uuid, data=self.data)