geobox 1.4.2__py3-none-any.whl → 2.0.1__py3-none-any.whl

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'] = []
@@ -344,9 +346,8 @@ 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()
-        
         self.params.append({
             'name': name,
             'value': value,
@@ -378,9 +379,8 @@ 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()
-        
         for i, param in enumerate(self.params):
             if param.get('name') == name:
                 self.params.pop(i)
@@ -424,9 +424,7 @@ class Query(Base):
             or
             >>> query = client.get_query(uuid="12345678-1234-5678-1234-567812345678")
             >>> query.execute(f='json')
-        """
-        self._check_access()
-        
+        """        
         if not self.sql:
             raise ValueError('"sql" parameter is required for this action!') 
         if not self.params:
@@ -499,7 +497,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')]
@@ -620,8 +617,14 @@ 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()
 
 
@@ -646,8 +649,6 @@ class Query(Base):
             >>> query = Query.get_query(client, uuid="12345678-1234-5678-1234-567812345678")
             >>> query.save_as_layer(layer_name='test')
         """
-        self._check_access()
-
         params = [{
             "name": item.get('name'),
             "type": item.get('type'),
@@ -665,3 +666,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('/'):
@@ -848,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)

geobox/tileset.py

@@ -9,14 +9,11 @@ from .task import Task
 if TYPE_CHECKING:
     from . import GeoboxClient 
     from .user import User 
+    from .aio import AsyncGeoboxClient
+    from .aio.tileset import Tileset as AsyncTileset
 
 class Tileset(Base):
-    """
-    A class to interact with tilesets in Geobox.
 
-    This class provides functionality to interact with tilesets in Geobox.
-    It supports various operations including CRUD operations on tilesets, as well as advanced operations like getting layers, and sharing tilesets.
-    """
     BASE_ENDPOINT: str = 'tilesets/'
 
     def __init__(self, 
@@ -635,3 +632,27 @@ class Tileset(Base):
             >>> tileset.clear_cache()
         """
         super()._clear_cache(endpoint=self.endpoint)
+
+
+    def to_async(self, async_client: 'AsyncGeoboxClient') -> 'AsyncTileset':
+        """
+        Switch to async version of the tileset 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.tileset.Tileset: the async instance of the tileset.
+
+        Example:
+            >>> from geobox import Geoboxclient
+            >>> from geobox.aio import AsyncGeoboxClient
+            >>> from geobox.tileset import Tileset
+            >>> client = GeoboxClient()
+            >>> tileset = Tileset.get_tileset(client, uuid="12345678-1234-5678-1234-567812345678")
+            >>> async with AsyncGeoboxClient() as async_client:
+            >>>     async_tileset = tileset.to_async(async_client)
+        """
+        from .aio.tileset import Tileset as AsyncTileset
+
+        return AsyncTileset(api=async_client, uuid=self.uuid, data=self.data)

geobox/usage.py

@@ -10,6 +10,8 @@ from .enums import UsageScale, UsageParam
 
 if TYPE_CHECKING:
     from . import GeoboxClient
+    from .aio import AsyncGeoboxClient
+    from .aio.usage import Usage as AsyncUsage
 
 
 class Usage(Base):
@@ -208,4 +210,33 @@ class Usage(Base):
             'user_id': user_id if user_id else None
         })
         endpoint = f"{cls.BASE_ENDPOINT}update"
-        return api.post(endpoint, payload=data)
+        return api.post(endpoint, payload=data)
+    
+
+    def to_async(self, async_client: 'AsyncGeoboxClient') -> 'AsyncUsage':
+        """
+        Switch to async version of the usage 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.usage.Usage: the async instance of the usage.
+
+        Example:
+            >>> from geobox import Geoboxclient
+            >>> from geobox.aio import AsyncGeoboxClient
+            >>> from geobox.usage import Usage
+            >>> client = GeoboxClient()
+            >>> user = client.get_user()
+            >>> usage = Usage.get_api_usage(client, 
+            ...                               resource=user, 
+            ...                               scale=UsageScale.Day, 
+            ...                               param=UsageParam.Calls, 
+            ...                               days_before_now=5)
+            >>> async with AsyncGeoboxClient() as async_client:
+            >>>     async_usage = usage.to_async(async_client)
+        """
+        from .aio.usage import Usage as AsyncUsage
+
+        return AsyncUsage(api=async_client, user=self.user)

geobox/user.py

@@ -8,6 +8,9 @@ from .plan import Plan
 
 if TYPE_CHECKING:
     from . import GeoboxClient
+    from .aio import AsyncGeoboxClient
+    from .aio.user import Session as AsyncSession
+    from .aio.user import User as AsyncUser
 
 
 class User(Base):
@@ -270,7 +273,7 @@ class User(Base):
             >>> from geobox.user import User
             >>> client = GeoboxClient()
             >>> user = User.get_user(client, user_id=1)
-            >>> user.update_user(status=UserStatus.PENDING)
+            >>> user.update(status=UserStatus.PENDING)
         """
         data = {
             "username": kwargs.get('username'),
@@ -337,9 +340,9 @@ class User(Base):
             or
             >>> user = client.get_user(user_id=1)
 
-            >>> user.get_user_sessions()       
+            >>> user.get_sessions()       
             or
-            >>> client.get_user_sessions()
+            >>> client.get_sessions()
         """
         params = clean_data({
             'f': 'json'
@@ -370,7 +373,7 @@ class User(Base):
             >>> from geobox import GeoboxClient
             >>> from geobox.user import User
             >>> client = GeoboxClient()
-            >>> user = client.get_user()
+            >>> user = client.get_user(user_id=1)
             >>> user.change_password(new_password='user_new_password')
         """
         data = clean_data({
@@ -382,7 +385,7 @@ class User(Base):
 
     def renew_plan(self) -> None:
         """
-        Renew the user plan
+        Renew the user plan (privileges required)
 
         Returns:
             None
@@ -396,6 +399,31 @@ class User(Base):
         self.api.post(endpoint)
 
 
+    def to_async(self, async_client: 'AsyncGeoboxClient') -> 'AsyncUser':
+        """
+        Switch to async version of the user 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.user.User: the async instance of the user.
+
+        Example:
+            >>> from geobox import Geoboxclient
+            >>> from geobox.aio import AsyncGeoboxClient
+            >>> from geobox.user import User
+            >>> client = GeoboxClient()
+            >>> user = User.get_user(client) # without user_id parameter, it gets the current user
+            or
+            >>> user = client.get_user() # without user_id parameter, it gets the current user
+            >>> async with AsyncGeoboxClient() as async_client:
+            >>>     async_user = user.to_async(async_client)
+        """
+        from .aio.user import User as AsyncUser
+
+        return AsyncUser(api=async_client, user_id=self.user_id, data=self.data)
+
 
 
 class Session(Base):
@@ -445,4 +473,32 @@ class Session(Base):
             'user_id': self.user.user_id,
             'session_uuid': self.uuid
         })
-        self.user.api.post(self.endpoint, data)
+        self.user.api.post(self.endpoint, data)
+
+
+    def to_async(self, async_client: 'AsyncGeoboxClient') -> 'AsyncSession':
+        """
+        Switch to async version of the session 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.user.Session: the async instance of the session.
+
+        Example:
+            >>> from geobox import Geoboxclient
+            >>> from geobox.aio import AsyncGeoboxClient
+            >>> from geobox.user import User
+            >>> client = GeoboxClient()
+            >>> user = User.get_user(client) # without user_id parameter, it gets the current user
+            or
+            >>> user = client.get_user() # without user_id parameter, it gets the current user
+            >>> session = user.get_sessions()[0]
+            >>> async with AsyncGeoboxClient() as async_client:
+            >>>     async_session = session.to_async(async_client)
+        """
+        from .aio.user import Session as AsyncSession
+        
+        async_user = self.user.to_async(async_client=async_client)
+        return AsyncSession(uuid=self.uuid, data=self.data, user=async_user)

geobox/utils.py

@@ -1,5 +1,6 @@
 from urllib.parse import urlparse, parse_qs, urlencode, urlunparse
 import base64
+import os
 
 
 def xor_encode(s, key=42):
@@ -8,6 +9,39 @@ def xor_encode(s, key=42):
     return encoded_bytes.decode('utf-8')
 
 
+def get_save_path(save_path: str = None) -> str:
+    """
+    Get the path where the file should be saved.
+
+    Args:
+        save_path (str, optional): The path to save the file.
+
+    Returns:
+        str: The path where the file is saved.
+    
+    Raises:
+        ValueError: If save_path does not end with a '/'.
+    """
+    # 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 get_unique_filename(save_path: str, file_name: str) -> str:
+    base, ext = os.path.splitext(file_name)
+    counter = 1
+    new_file = f"{save_path}{base}({counter}){ext}"
+    while os.path.exists(new_file):
+        new_file = f"{save_path}{base}({counter}){ext}"
+        counter += 1
+    return new_file
+
+
 def clean_data(data: dict) -> dict:
     """
     Cleans the input data by removing keys with None values.