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

geobox/feature.py

@@ -6,15 +6,12 @@ from .enums import FeatureType
 
 if TYPE_CHECKING:
     from .vectorlayer import VectorLayer
+    from .aio import AsyncGeoboxClient
+    from .aio.feature import Feature as AsyncFeature
+
 
 class Feature(Base):
-    """
-    A class representing a feature in a vector layer in Geobox.
 
-    This class provides functionality to create, manage, and manipulate features in a vector layer.
-    It supports various operations including CRUD operations on features, as well as advanced operations like transforming geometries.
-    It also provides properties to access the feature geometry and properties, and a method to transform the feature geometry.
-    """
     BASE_SRID = 3857
 
     def __init__(self, 
@@ -163,10 +160,10 @@ class Feature(Base):
     @property
     def length(self) -> float:
         """
-        Returns the length of thefeature geometry (geometry package extra is required!)
+        Returns the length of the feature geometry (geometry package extra is required!)
 
         Returns:
-            float: the length of thefeature geometry
+            float: the length of the feature geometry
 
         Example:
             >>> from geobox import GeoboxClient
@@ -266,11 +263,11 @@ class Feature(Base):
             >>> layer = client.get_vector(uuid="12345678-1234-5678-1234-567812345678")
             >>> feature = layer.get_feature(id=1)
             >>> geojson = {
-                "geometry": {
-                    "type": "Point",
-                    "coordinates": [10, 20]
-                }
-            }
+            ...     "geometry": {
+            ...         "type": "Point",
+            ...         "coordinates": [10, 20]
+            ...     }
+            ... }
             >>> feature.update(geojson)
         """
         return super()._update(self.endpoint, geojson, clean=False)
@@ -506,3 +503,26 @@ class Feature(Base):
         return self
 
 
+    def to_async(self, async_client: 'AsyncGeoboxClient') -> 'AsyncFeature':
+        """
+        Switch to async version of the feature 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.feature.Feature: the async instance of the feature.
+
+        Example:
+            >>> from geobox import Geoboxclient
+            >>> from geobox.aio import AsyncGeoboxClient
+            >>> client = GeoboxClient()
+            >>> layer = client.get_vector(uuid="12345678-1234-5678-1234-567812345678")
+            >>> feature = layer.get_feature(id=1, srid=3857)
+            >>> async with AsyncGeoboxClient() as async_client:
+            >>>     async_feature = feature.to_async(async_client)
+        """
+        from .aio.feature import Feature as AsyncFeature
+
+        async_layer = self.layer.to_async(async_client=async_client)
+        return AsyncFeature(layer=async_layer, srid=self.srid, data=self.data)

geobox/field.py

@@ -8,15 +8,12 @@ from .enums import FieldType
 if TYPE_CHECKING:
     from .api import GeoboxClient
     from .vectorlayer import VectorLayer
+    from .aio import AsyncGeoboxClient
+    from .aio.field import Field as AsyncField
+
 
 class Field(Base):
-    """
-    A class representing a field in a vector layer in Geobox.
 
-    This class provides functionality to create, manage, and manipulate fields in a vector layer.
-    It supports various operations including CRUD operations on fields, as well as advanced operations like getting unique values, statistics, and updating fields.
-    It also provides properties to access the field data, and a method to update the field.
-    """
     def __init__(self, 
                  layer: 'VectorLayer',
                  data_type: 'FieldType',
@@ -30,17 +27,6 @@ class Field(Base):
             data_type (FieldType): type of the field
             field_id (int): the id of the field
             data (Dict, optional): The data of the field.
-
-        Example:
-            >>> from geobox import GeoboxClient
-            >>> from geobox.field import Field
-            >>> client = GeoboxClient()
-            >>> layer = client.get_vector(uuid="12345678-1234-5678-1234-567812345678")
-            >>> field_data = {
-            ...     "name": "test"
-            ... }
-            >>> field = Field(layer=layer, data_type=FieldType.Integere, data=field_data)
-            >>> field.save()
         """
         super().__init__(api=layer.api, data=data)
         self.layer = layer
@@ -202,7 +188,7 @@ class Field(Base):
             >>> from geobox.field import Field
             >>> client = GeoboxClient()
             >>> layer = client.get_vector(uuid="12345678-1234-5678-1234-567812345678")
-            >>> field = Field(layer=layer, data_type=FieldType.String)
+            >>> field = layer.get_field(name='test')
             >>> field.update(name="my_field", display_name="My Field", description="My Field Description")
         """       
         data = {
@@ -234,12 +220,12 @@ class Field(Base):
         return self.layer.api.get(endpoint)
 
 
-    def get_field_unique_values_numbers(self) -> Dict:
+    def get_field_unique_values_numbers(self) -> int:
         """
-        Get the unique values of the field.
+        Get the count of unique values of the field.
 
         Returns:
-            Dict: The response data.
+            int: The count of the field unique values.
 
         Example:
             >>> from geobox import GeoboxClient
@@ -307,3 +293,29 @@ class Field(Base):
 
         self.save()
         return self.domain
+
+
+    def to_async(self, async_client: 'AsyncGeoboxClient') -> 'AsyncField':
+        """
+        Switch to async version of the field 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.field.Field: the async instance of the field.
+
+        Example:
+            >>> from geobox import Geoboxclient
+            >>> from geobox.aio import AsyncGeoboxClient
+            >>> from geobox.field import Field
+            >>> client = GeoboxClient()
+            >>> layer = client.get_vector(uuid="12345678-1234-5678-1234-567812345678")
+            >>> field = layer.get_field(name='test')
+            >>> async with AsyncGeoboxClient() as async_client:
+            >>>     async_field = field.to_async(async_client)
+        """
+        from .aio.field import Field as AsyncField
+
+        async_layer = self.layer.to_async(async_client=async_client)
+        return AsyncField(layer=async_layer, data_type=self.data_type, field_id=self.field_id, data=self.data)

geobox/file.py

@@ -5,26 +5,22 @@ import mimetypes
 from geobox.exception import ValidationError
 import requests
 import sys
-from pathlib import Path
 
 from .base import Base
 from .enums import FileFormat, PublishFileType, InputGeomType, FileType
-from .utils import clean_data
+from .utils import clean_data, get_unique_filename, get_save_path
 from .task import Task
 from .feature import Feature
 
 if TYPE_CHECKING:
     from . import GeoboxClient 
     from .user import User
+    from .aio import AsyncGeoboxClient
+    from .aio.file import File as AsyncFile
+
 
 class File(Base):
-    """
-    A class to interact with files in Geobox.
 
-    This class provides functionality to interact with files in Geobox.
-    It supports various operations including CRUD operations on files, as well as advanced operations like publishing, and sharing files.
-    It also provides properties to access the file data, and a method to download the file.
-    """
     BASE_ENDPOINT: str = 'files/'
 
     def __init__(self, 
@@ -35,7 +31,7 @@ class File(Base):
         Constructs all the necessary attributes for the File object.
 
         Args:
-            api (Api): The API instance.
+            api (GeoboxClient): The GeoboxClient instance.
             uuid (str): The UUID of the file.
             data (Dict, optional): The data of the file.
         """
@@ -92,7 +88,7 @@ class File(Base):
         Upload a file to the GeoBox API.
 
         Args:
-            api (GeoboxClient): The API instance.
+            api (GeoboxClient): The GeoboxClient instance.
             path (str): The path to the file to upload.
             user_id (int, optional): specific user. privileges required.
             scan_archive (bool, optional): Whether to scan the archive for layers. default: True
@@ -143,7 +139,7 @@ class File(Base):
             q (str): query filter based on OGC CQL standard. e.g. "field1 LIKE '%GIS%' AND created_at > '2021-01-01'"
             search (str): search term for keyword-based searching among search_fields or all textual fields if search_fields does not have value. NOTE: if q param is defined this param will be ignored.
             search_fields (str): comma separated list of fields for searching
-            order_by (str): comma separated list of fields for sorting results [field1 A|D, field2 A|D, …]. e.g. name A, type D.NOTE: "A" denotes ascending order and "D" denotes descending order.
+            order_by (str): comma separated list of fields for sorting results [field1 A|D, field2 A|D, …]. e.g. name A, type D. NOTE: "A" denotes ascending order and "D" denotes descending order.
             return_count (bool): if true, the total number of results will be returned. default is False.
             skip (int): number of results to skip. default is 0.
             limit (int): number of results to return. default is 10.
@@ -182,7 +178,7 @@ class File(Base):
         Retrieves a file by its UUID.
 
         Args:
-            api (Api): The API instance.
+            api (Api): The GeoboxClient instance.
             uuid (str): The UUID of the file.
             user_id (int, optional): specific user. privileges required.
 
@@ -229,37 +225,7 @@ class File(Base):
             >>> files = client.get_files_by_name(name='test')
         """
         return cls.get_files(api, q=f"name = '{name}'", user_id=user_id)
-    
 
-    def _get_save_path(self, 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 '/'.
-
-        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 _get_file_name(self, response: requests.Response) -> str:
         """
@@ -301,7 +267,7 @@ class File(Base):
                 )
 
 
-    def download(self, save_path: str = None, progress_bar: bool = True) -> str:
+    def download(self, save_path: str = None, progress_bar: bool = True, file_name: str = None, overwrite: bool = False) -> str:
         """
         Download a file and save it to the specified path.
         
@@ -310,6 +276,8 @@ class File(Base):
                                     If not provided, it saves to the current working directory
                                     using the original filename and appropriate extension.
             progress_bar (bool, optional): Whether to show a progress bar. default: True
+            file_name (str, optional): the downloaded file name.
+            overwrite (bool, optional): whether to overwrite the downloaded file if it exists on the save path. default is False.
         
         Returns:
             str: Path where the file was saved
@@ -328,12 +296,14 @@ class File(Base):
         if not self.uuid:
             raise ValueError("File UUID is required to download the file")
         
-        save_path = self._get_save_path(save_path)
+        save_path = get_save_path(save_path)
         os.makedirs(os.path.dirname(save_path), exist_ok=True)
         
         with self.api.get(f"{self.endpoint}download/", stream=True) as response:
-            file_name = self._get_file_name(response)
+            file_name = self._get_file_name(response) if not file_name else file_name
             full_path = f"{save_path}/{file_name}"
+            if os.path.exists(full_path) and not overwrite:
+                full_path = get_unique_filename(save_path, file_name)
             with open(full_path, 'wb') as f:
                 pbar = self._create_progress_bar() if progress_bar else None
                 for chunk in response.iter_content(chunk_size=8192):
@@ -381,7 +351,7 @@ class File(Base):
 
         Args:
             name (str): The name of the layer.
-            publish_as (PublishFileType): The type of layer to publish as.
+            publish_as (PublishFileType, optional): The type of layer to publish as.
             input_geom_type (InputGeomType, optional): The geometry type of the layer.
             input_layer (str, optional): The name of the input layer.
             input_dataset (str, optional): The name of the input dataset.
@@ -521,3 +491,27 @@ class File(Base):
             'limit': limit
         }
         return super()._get_shared_users(self.endpoint, params)
+
+
+    def to_async(self, async_client: 'AsyncGeoboxClient') -> 'AsyncFile':
+        """
+        Switch to async version of the file 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.file.File: the async instance of the file.
+
+        Example:
+            >>> from geobox import Geoboxclient
+            >>> from geobox.aio import AsyncGeoboxClient
+            >>> from geobox.file import File
+            >>> client = GeoboxClient()
+            >>> file = File.get_file(client, uuid="12345678-1234-5678-1234-567812345678")
+            >>> async with AsyncGeoboxClient() as async_client:
+            >>>     async_file = file.to_async(async_client)
+        """
+        from .aio.file import File as AsyncFile
+
+        return AsyncFile(api=async_client, uuid=self.uuid, data=self.data)

geobox/layout.py

@@ -5,6 +5,9 @@ from .base import Base
 if TYPE_CHECKING:
     from . import GeoboxClient
     from .user import User
+    from .aio import AsyncGeoboxClient
+    from .aio.layout import Layout as AsyncLayout
+
 
 class Layout(Base):
 
@@ -197,7 +200,7 @@ class Layout(Base):
             >>> from geobox.layout import Layout
             >>> client = GeoboxClient()
             >>> layout = Layout.get_layout(client, uuid="12345678-1234-5678-1234-567812345678")
-            >>> layout.update_layout(display_name="New Display Name")
+            >>> layout.update(display_name="New Display Name")
         """
         data = {
             "name": kwargs.get('name'),
@@ -312,3 +315,27 @@ class Layout(Base):
             'limit': limit
         }
         return super()._get_shared_users(self.endpoint, params)
+
+
+    def to_async(self, async_client: 'AsyncGeoboxClient') -> 'AsyncLayout':
+        """
+        Switch to async version of the layout 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.layout.Layout: the async instance of the layout.
+
+        Example:
+            >>> from geobox import Geoboxclient
+            >>> from geobox.aio import AsyncGeoboxClient
+            >>> from geobox.layout import Layout
+            >>> client = GeoboxClient()
+            >>> layout = Layout.get_layout(client, uuid="12345678-1234-5678-1234-567812345678")
+            >>> async with AsyncGeoboxClient() as async_client:
+            >>>     async_layout = layout.to_async(async_client)
+        """
+        from .aio.layout import Layout as AsyncLayout
+
+        return AsyncLayout(api=async_client, uuid=self.uuid, data=self.data)

geobox/log.py

@@ -1,12 +1,12 @@
-from urllib.parse import urljoin
 from typing import Optional, Dict, List, Union, TYPE_CHECKING
-from datetime import datetime
 
 from .base import Base
 
 if TYPE_CHECKING:
     from . import GeoboxClient
     from .user import User
+    from .aio import AsyncGeoboxClient
+    from .aio.log import Log as AsyncLog
 
 
 class Log(Base):
@@ -21,7 +21,7 @@ class Log(Base):
         Constructs all the necessary attributes for the Log object.
 
         Args:
-            api (Api): The GeoboxClient instance for making requests.
+            api (GeoboxClient): The GeoboxClient instance for making requests.
             log_id (int): The id of the log.
             data (Dict, optional): The data of the log.
         """
@@ -63,7 +63,7 @@ class Log(Base):
             List[Log]: a list of logs
 
         Example: 
-            >>> from geobox import Geobox
+            >>> from geobox import GeoboxClient
             >>> from geopox.log import Log
             >>> client = GeoboxClient()
             >>> logs = Log.get_logs(client)
@@ -92,7 +92,7 @@ class Log(Base):
             None
 
         Example:
-            >>> from geobox import Geobox
+            >>> from geobox import GeoboxClient
             >>> from geopox.log import Log
             >>> client = GeoboxClient()
             >>> log = Log.get_logs(client)[0]
@@ -111,10 +111,34 @@ class Log(Base):
             User | None: if the log has owner user 
 
         Example:
-            >>> from geobox import Geobox
+            >>> from geobox import GeoboxClient
             >>> from geopox.log import Log
             >>> client = GeoboxClient()
             >>> log = Log.get_logs(client)[0]
             >>> log.user
         """
-        return self.api.get_user(self.owner_id)
+        return self.api.get_user(self.owner_id)
+    
+
+    def to_async(self, async_client: 'AsyncGeoboxClient') -> 'AsyncLog':
+        """
+        Switch to async version of the log 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.log.Log: the async instance of the log.
+
+        Example:
+            >>> from geobox import Geoboxclient
+            >>> from geobox.aio import AsyncGeoboxClient
+            >>> from geopox.log import Log
+            >>> client = GeoboxClient()
+            >>> log = Log.get_logs(client)[0]
+            >>> async with AsyncGeoboxClient() as async_client:
+            >>>     async_log = log.to_async(async_client)
+        """
+        from .aio.log import Log as AsyncLog
+
+        return AsyncLog(api=async_client, log_id=self.log_id, data=self.data)

geobox/map.py

@@ -12,7 +12,8 @@ if TYPE_CHECKING:
     from .user import User
     from .task import Task
     from .attachment import Attachment
-
+    from .aio import AsyncGeoboxClient
+    from .aio.map import Map as AsyncMap
 
 
 class Map(Base):
@@ -636,6 +637,13 @@ class Map(Base):
 
         Returns:
             Dict: The response of the API.
+
+        Example:
+            >>> from geobox import GeoboxClient
+            >>> from geobox.map import Map
+            >>> client = GeoboxClient()
+            >>> map = Map.get_map(uuid="12345678-1234-5678-1234-567812345678")
+            >>> map.set_settings(zoom=10)
         """
         general_settings = {'map_unit', 'base_map', 'flash_color', 'highlight_color', 
                             'selection_color', 'selectable_layers', 'calendar_type', 'custom_basemaps', 'show_maptip_on'}
@@ -998,4 +1006,28 @@ class Map(Base):
                                             file=file,
                                             feature=feature,
                                             display_name=display_name,
-                                            description=description)
+                                            description=description)
+    
+
+    def to_async(self, async_client: 'AsyncGeoboxClient') -> 'AsyncMap':
+        """
+        Switch to async version of the map 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.map.Map: the async instance of the map.
+
+        Example:
+            >>> from geobox import Geoboxclient
+            >>> from geobox.aio import AsyncGeoboxClient
+            >>> from geobox.map import Map
+            >>> client = GeoboxClient()
+            >>> map = Map.get_map(client, uuid="12345678-1234-5678-1234-567812345678")
+            >>> async with AsyncGeoboxClient() as async_client:
+            >>>     async_map = map.to_async(async_client)
+        """
+        from .aio.map import Map as AsyncMap
+
+        return AsyncMap(api=async_client, uuid=self.uuid, data=self.data)

geobox/model3d.py

@@ -3,20 +3,20 @@ from urllib.parse import urljoin, urlencode
 import os
 import zipfile
 import sys
-import requests
-import mimetypes
 
 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, 
@@ -221,36 +221,6 @@ class Model(Base):
         super().delete(self.endpoint)
 
 
-    def _get_save_path(self, 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 '/'.
-
-        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:
@@ -289,7 +259,7 @@ class Model(Base):
             >>> from geobox import GeoboxClient
             >>> client = GeoboxClient()
             >>> model = client.get_models()[0]
-            >>> model.get_content()
+            >>> model.download()
         """
         if not self.uuid:
             raise ValueError("Model UUID is required to download content")
@@ -299,7 +269,7 @@ class Model(Base):
         else:
             model = self
 
-        save_path = model._get_save_path(save_path)
+        save_path = get_save_path(save_path)
         os.makedirs(save_path, exist_ok=True)
 
         endpoint = urljoin(model.api.base_url, f"{model.endpoint}/content/")
@@ -415,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'),
@@ -673,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)