geobox 2.1.0__py3-none-any.whl → 2.2.1__py3-none-any.whl

geobox/aio/tileset.py

@@ -2,24 +2,24 @@ from urllib.parse import urljoin
 from typing import Dict, List, Optional, Union, TYPE_CHECKING
 
 from .base import AsyncBase
-from .vectorlayer import VectorLayer
-from .view import VectorLayerView
-from .task import Task
+from .vectorlayer import AsyncVectorLayer
+from .view import AsyncVectorLayerView
+from .task import AsyncTask
 
 if TYPE_CHECKING:
     from . import AsyncGeoboxClient 
-    from .user import User 
-    from ..api import GeoboxClient as SyncGeoboxClient
-    from ..tileset import Tileset as SyncTileset
+    from .user import AsyncUser 
+    from ..api import GeoboxClient
+    from ..tileset import Tileset
 
-class Tileset(AsyncBase):
+class AsyncTileset(AsyncBase):
 
     BASE_ENDPOINT: str = 'tilesets/'
 
     def __init__(self, 
-                api: 'AsyncGeoboxClient', 
-                uuid: str, 
-                data: Optional[Dict] = {}):
+        api: 'AsyncGeoboxClient', 
+        uuid: str, 
+        data: Optional[Dict] = {}):
         """
         Constructs all the necessary attributes for the Tilesets object.
 
@@ -32,8 +32,15 @@ class Tileset(AsyncBase):
 
 
     @classmethod
-    async def create_tileset(cls, api: 'AsyncGeoboxClient', name: str, layers: List[Union['VectorLayer', 'VectorLayerView']], display_name: str = None, description: str = None,
-                        min_zoom: int = None, max_zoom: int = None, user_id: int = None) -> 'Tileset':
+    async def create_tileset(cls, 
+        api: 'AsyncGeoboxClient', 
+        name: str, 
+        layers: List[Union['AsyncVectorLayer', 'AsyncVectorLayerView']], 
+        display_name: str = None, 
+        description: str = None,
+        min_zoom: int = None, 
+        max_zoom: int = None, 
+        user_id: int = None) -> 'AsyncTileset':
         """
         [async] Create a new tileset.
 
@@ -48,15 +55,15 @@ class Tileset(AsyncBase):
             user_id (int, optional): Specific user. privileges required.
 
         Returns:
-            Tileset: The created tileset instance.
+            AsyncTileset: The created tileset instance.
 
         Example:
             >>> from geobox.aio import AsyncGeoboxClient
-            >>> from geobox.aio.tileset import Tileset
+            >>> from geobox.aio.tileset import AsyncTileset
             >>> async with AsyncGeoboxClient() as client:
             >>>     layer = await client.get_vector(uuid="12345678-1234-5678-1234-567812345678")
             >>>     view = await client.get_view(uuid="12345678-1234-5678-1234-567812345678")
-            >>>     tileset = await Tileset.create_tileset(client, 
+            >>>     tileset = await AsyncTileset.create_tileset(client, 
             ...                                             name="your_tileset_name", 
             ...                                             display_name="Your Tileset", 
             ...                                             description="Your description", 
@@ -73,10 +80,10 @@ class Tileset(AsyncBase):
         """
         formatted_layers = []
         for item in layers:
-            if type(item) == VectorLayer:
+            if type(item) == AsyncVectorLayer:
                 item_type = 'vector'
 
-            elif type(item) == VectorLayerView:
+            elif type(item) == AsyncVectorLayerView:
                 item_type = 'view'
 
             else:
@@ -96,11 +103,11 @@ class Tileset(AsyncBase):
             "layers": formatted_layers,
             "user_id": user_id
         }
-        return await super()._create(api, cls.BASE_ENDPOINT, data, factory_func=lambda api, item: Tileset(api, item['uuid'], item))
+        return await super()._create(api, cls.BASE_ENDPOINT, data, factory_func=lambda api, item: AsyncTileset(api, item['uuid'], item))
 
 
     @classmethod
-    async def get_tilesets(cls, api: 'AsyncGeoboxClient', **kwargs) -> Union[List['Tileset'], int]:
+    async def get_tilesets(cls, api: 'AsyncGeoboxClient', **kwargs) -> Union[List['AsyncTileset'], int]:
         """
         [async] Retrieves a list of tilesets.
 
@@ -119,13 +126,13 @@ class Tileset(AsyncBase):
             shared (bool): Whether to return shared tilesets. default is False.
 
         Returns:
-            List[Tileset] | int: A list of Tileset instances or the total number of tilesets
+            List[AsyncTileset] | int: A list of Tileset instances or the total number of tilesets
 
         Example:
             >>> from geobox.aio import AsyncGeoboxClient
-            >>> from geobox.aio.tileset import Tileset
+            >>> from geobox.aio.tileset import AsyncTileset
             >>> async with AsyncGeoboxClient() as client:
-            >>>     tilesets = await Tileset.get_tilesets(client,
+            >>>     tilesets = await AsyncTileset.get_tilesets(client,
             ...         q="name LIKE '%your_tileset_name%'",
             ...         order_by="name A",
             ...         skip=0,
@@ -150,11 +157,11 @@ class Tileset(AsyncBase):
             'user_id': kwargs.get('user_id', None),
             'shared': kwargs.get('shared', False)
         }
-        return await super()._get_list(api=api, endpoint=cls.BASE_ENDPOINT, params=params, factory_func=lambda api, item: Tileset(api, item['uuid'], item))
+        return await super()._get_list(api=api, endpoint=cls.BASE_ENDPOINT, params=params, factory_func=lambda api, item: AsyncTileset(api, item['uuid'], item))
     
 
     @classmethod
-    async def get_tilesets_by_ids(cls, api: 'AsyncGeoboxClient', ids: List[str], user_id: int = None) -> List['Tileset']:
+    async def get_tilesets_by_ids(cls, api: 'AsyncGeoboxClient', ids: List[str], user_id: int = None) -> List['AsyncTileset']:
         """
         [async] Retrieves a list of tilesets by their IDs.
 
@@ -164,13 +171,13 @@ class Tileset(AsyncBase):
             user_id (int, optional): Specific user. privileges required.
 
         Returns:
-            List[Tileset]: A list of Tileset instances.
+            List[AsyncTileset]: A list of Tileset instances.
 
         Example:
             >>> from geobox.aio import AsyncGeoboxClient
-            >>> from geobox.aio.tileset import Tileset
+            >>> from geobox.aio.tileset import AsyncTileset
             >>> async with AsyncGeoboxClient() as client:
-            >>>     tilesets = await Tileset.get_tilesets_by_ids(client, ids=['123', '456'])
+            >>>     tilesets = await AsyncTileset.get_tilesets_by_ids(client, ids=['123', '456'])
             or  
             >>>     tilesets = await client.get_tilesets_by_ids(ids=['123', '456'])
         """
@@ -178,11 +185,11 @@ class Tileset(AsyncBase):
             'ids': ids,
             'user_id': user_id
         }
-        return await super()._get_list_by_ids(api, cls.BASE_ENDPOINT, params, factory_func=lambda api, item: Tileset(api, item['uuid'], item))
+        return await super()._get_list_by_ids(api, cls.BASE_ENDPOINT, params, factory_func=lambda api, item: AsyncTileset(api, item['uuid'], item))
 
 
     @classmethod
-    async def get_tileset(cls, api: 'AsyncGeoboxClient', uuid: str) -> 'Tileset':
+    async def get_tileset(cls, api: 'AsyncGeoboxClient', uuid: str) -> 'AsyncTileset':
         """
         [async] Retrieves a tileset by its UUID.
 
@@ -191,21 +198,21 @@ class Tileset(AsyncBase):
             uuid (str): The UUID of the tileset.
 
         Returns:
-            Tileset: The retrieved tileset instance.
+            AsyncTileset: The retrieved tileset instance.
 
         Example:
             >>> from geobox.aio import AsyncGeoboxClient
-            >>> from geobox.aio.tileset import Tileset
+            >>> from geobox.aio.tileset import AsyncTileset
             >>> async with AsyncGeoboxClient() as client:
-            >>>     tileset = await Tileset.get_tileset(client, uuid="12345678-1234-5678-1234-567812345678")
+            >>>     tileset = await AsyncTileset.get_tileset(client, uuid="12345678-1234-5678-1234-567812345678")
             or  
             >>>     tileset = await client.get_tileset(uuid="12345678-1234-5678-1234-567812345678")
         """
-        return await super()._get_detail(api, cls.BASE_ENDPOINT, uuid, factory_func=lambda api, item: Tileset(api, item['uuid'], item))
+        return await super()._get_detail(api, cls.BASE_ENDPOINT, uuid, factory_func=lambda api, item: AsyncTileset(api, item['uuid'], item))
 
 
     @classmethod
-    async def get_tileset_by_name(cls, api: 'AsyncGeoboxClient', name: str, user_id: int = None) -> Union['Tileset', None]:
+    async def get_tileset_by_name(cls, api: 'AsyncGeoboxClient', name: str, user_id: int = None) -> Union['AsyncTileset', None]:
         """
         [async] Get a tileset by name
 
@@ -215,11 +222,11 @@ class Tileset(AsyncBase):
             user_id (int, optional): specific user. privileges required.
 
         Returns:
-            Tileset | None: returns the tileset if a tileset matches the given name, else None
+            AsyncTileset | None: returns the tileset if a tileset matches the given name, else None
 
         Example:
             >>> from geobox.aio import AsyncGeoboxClient
-            >>> from geobox.aio.tileset import Tileset
+            >>> from geobox.aio.tileset import AsyncTileset
             >>> async with AsyncGeoboxClient() as client:
             >>>     tileset = await VectorLayer.get_tileset_by_name(client, name='test')
             or  
@@ -248,9 +255,9 @@ class Tileset(AsyncBase):
 
         Example:
             >>> from geobox.aio import AsyncGeoboxClient
-            >>> from geobox.aio.tileset import Tileset
+            >>> from geobox.aio.tileset import AsyncTileset
             >>> async with AsyncGeoboxClient() as client:
-            >>>     tileset = await Tileset.get_tileset(client, uuid="12345678-1234-5678-1234-567812345678")
+            >>>     tileset = await AsyncTileset.get_tileset(client, uuid="12345678-1234-5678-1234-567812345678")
             >>>     await tileset.update_tileset(
             ...         name="new_name",
             ...         display_name="New Display Name",
@@ -282,15 +289,15 @@ class Tileset(AsyncBase):
 
         Example:
             >>> from geobox.aio import AsyncGeoboxClient
-            >>> from geobox.aio.tileset import Tileset
+            >>> from geobox.aio.tileset import AsyncTileset
             >>> async with AsyncGeoboxClient() as client:
-            >>>     tileset = await Tileset.get_tileset(client, uuid="12345678-1234-5678-1234-567812345678")
+            >>>     tileset = await AsyncTileset.get_tileset(client, uuid="12345678-1234-5678-1234-567812345678")
             >>>     await tileset.delete()
         """
-        await super().delete(urljoin(self.BASE_ENDPOINT, f'{self.uuid}/'))
+        await super()._delete(urljoin(self.BASE_ENDPOINT, f'{self.uuid}/'))
     
     
-    async def get_layers(self, **kwargs) -> List['VectorLayer']:
+    async def get_layers(self, **kwargs) -> Union[List['AsyncVectorLayer'], List['AsyncVectorLayerView']]:
         """
         [async] Retrieves the layers of the tileset with optional parameters.
 
@@ -306,21 +313,13 @@ class Tileset(AsyncBase):
             shared (bool): if True, returns only the layers that has been shared with you. default is False.
 
         Returns:
-            List: A list of VectorLayer instances.
-
-        Raises:
-            ApiRequestError: If the API request fails.
-
-        Example:
-
-        Returns:
-            List: A list of VectorLayer or VectorLayerView instances.
+            AsyncVectorLayer | AsyncVectorLayerView: A list of VectorLayer or VectorLayerView instances.
 
         Example:
             >>> from geobox.aio import AsyncGeoboxClient
-            >>> from geobox.aio.tileset import Tileset
+            >>> from geobox.aio.tileset import AsyncTileset
             >>> async with AsyncGeoboxClient() as client:
-            >>>     tileset = await Tileset.get_tileset(client, uuid="12345678-1234-5678-1234-567812345678")
+            >>>     tileset = await AsyncTileset.get_tileset(client, uuid="12345678-1234-5678-1234-567812345678")
             >>>     layers = await tileset.get_layers()
         """
         params = {
@@ -336,16 +335,16 @@ class Tileset(AsyncBase):
             'shared': kwargs.get('shared', False)
         }
         endpoint = urljoin(self.BASE_ENDPOINT, f'{self.uuid}/layers/')
-        return await super()._get_list(self.api, endpoint, params, factory_func=lambda api, item: VectorLayer(api, item['uuid'], item['layer_type'], item) if not item['is_view'] else \
-                                                                                            VectorLayerView(api, item['uuid'], item['layer_type'], item)                                    )
+        return await super()._get_list(self.api, endpoint, params, factory_func=lambda api, item: AsyncVectorLayer(api, item['uuid'], item['layer_type'], item) if not item['is_view'] else \
+                                                                                            AsyncVectorLayerView(api, item['uuid'], item['layer_type'], item))
 
 
-    async def add_layer(self, layer: Union['VectorLayer', 'VectorLayerView']) -> None:
+    async def add_layer(self, layer: Union['AsyncVectorLayer', 'AsyncVectorLayerView']) -> None:
         """
         [async] Adds a layer to the tileset.
 
         Args:
-            layer (VectorLayer | VectorLayerView): the layer object to add to the tileset
+            layer (AsyncVectorLayer | AsyncVectorLayerView): the layer object to add to the tileset
 
         Returns:
             None
@@ -355,16 +354,16 @@ class Tileset(AsyncBase):
 
         Example:
             >>> from geobox.aio import AsyncGeoboxClient
-            >>> from geobox.aio.tileset import Tileset
+            >>> from geobox.aio.tileset import AsyncTileset
             >>> async with AsyncGeoboxClient() as client:
-            >>>     tileset = await Tileset.get_tileset(client, uuid="12345678-1234-5678-1234-567812345678")
+            >>>     tileset = await AsyncTileset.get_tileset(client, uuid="12345678-1234-5678-1234-567812345678")
             >>>     layer = await client.get_vector(uuid="12345678-1234-5678-1234-567812345678")
             >>>     await tileset.add_layer(layer)
         """
-        if type(layer) == VectorLayer:
+        if type(layer) == AsyncVectorLayer:
             layer_type = 'vector'
 
-        elif type(layer) == VectorLayerView:
+        elif type(layer) == AsyncVectorLayerView:
             layer_type = 'view'
 
         else:
@@ -379,12 +378,12 @@ class Tileset(AsyncBase):
         return await self.api.post(endpoint, data, is_json=False)
 
 
-    async def delete_layer(self, layer: Union['VectorLayer', 'VectorLayerView']) -> None:
+    async def delete_layer(self, layer: Union['AsyncVectorLayer', 'AsyncVectorLayerView']) -> None:
         """
         [async] Deletes a layer from the tileset.
 
         Args:
-            layer (VectorLayer | VectorLayerView): the layer object to delete from the tileset
+            layer (AsyncVectorLayer | AsyncVectorLayerView): the layer object to delete from the tileset
 
         Returns:
             None
@@ -394,16 +393,16 @@ class Tileset(AsyncBase):
 
         Example:
             >>> from geobox.aio import AsyncGeoboxClient
-            >>> from geobox.aio.tileset import Tileset
+            >>> from geobox.aio.tileset import AsyncTileset
             >>> async with AsyncGeoboxClient() as client:
-            >>>     tileset = await Tileset.get_tileset(client, uuid="12345678-1234-5678-1234-567812345678")
+            >>>     tileset = await AsyncTileset.get_tileset(client, uuid="12345678-1234-5678-1234-567812345678")
             >>>     layer = await client.get_vector(uuid="12345678-1234-5678-1234-567812345678")
             >>>     await tileset.delete_layer(layer)
         """
-        if type(layer) == VectorLayer:
+        if type(layer) == AsyncVectorLayer:
             layer_type = 'vector'
 
-        elif type(layer) == VectorLayerView:
+        elif type(layer) == AsyncVectorLayerView:
             layer_type = 'view'
 
         else:
@@ -418,49 +417,49 @@ class Tileset(AsyncBase):
         return await self.api.delete(endpoint, data, is_json=False)
 
 
-    async def share(self, users: List['User']) -> None:
+    async def share(self, users: List['AsyncUser']) -> None:
         """
         [async] Shares the file with specified users.
 
         Args:
-            users (List[User]): The list of user IDs to share the file with.
+            users (List[AsyncUser]): The list of user IDs to share the file with.
 
         Returns:
             None
 
         Example:
             >>> from geobox.aio import AsyncGeoboxClient
-            >>> from geobox.aio.tileset import Tileset
+            >>> from geobox.aio.tileset import AsyncTileset
             >>> async with AsyncGeoboxClient() as client:
-            >>>     tileset = await Tileset.get_tileset(client, uuid="12345678-1234-5678-1234-567812345678")
+            >>>     tileset = await AsyncTileset.get_tileset(client, uuid="12345678-1234-5678-1234-567812345678")
             >>>     users = await client.search_usesrs(search='John')
             >>>     await tileset.share(users=users)
         """
         await super()._share(self.endpoint, users)
     
 
-    async def unshare(self, users: List['User']) -> None:
+    async def unshare(self, users: List['AsyncUser']) -> None:
         """
         [async] Unshares the file with specified users.
 
         Args:
-            users (List[User]): The list of user IDs to unshare the file with.
+            users (List[AsyncUser]): The list of user IDs to unshare the file with.
 
         Returns:
             None
 
         Example:
             >>> from geobox.aio import AsyncGeoboxClient
-            >>> from geobox.aio.tileset import Tileset
+            >>> from geobox.aio.tileset import AsyncTileset
             >>> async with AsyncGeoboxClient() as client:
-            >>>     tileset = await Tileset.get_tileset(client, uuid="12345678-1234-5678-1234-567812345678")
+            >>>     tileset = await AsyncTileset.get_tileset(client, uuid="12345678-1234-5678-1234-567812345678")
             >>>     users = await client.search_usesrs(search='John')
             >>>     await tileset.unshare(users=users)
         """
         await super()._unshare(self.endpoint, users)
 
 
-    async def get_shared_users(self, search: str = None, skip: int = 0, limit: int = 10) -> List['User']:
+    async def get_shared_users(self, search: str = None, skip: int = 0, limit: int = 10) -> List['AsyncUser']:
         """
         [async] Retrieves the list of users the file is shared with.
 
@@ -470,13 +469,13 @@ class Tileset(AsyncBase):
             limit (int, optional): The maximum number of users to retrieve.
 
         Returns:
-            List[User]: The list of shared users.
+            List[AsyncUser]: The list of shared users.
 
         Example:
             >>> from geobox.aio import AsyncGeoboxClient
-            >>> from geobox.aio.tileset import Tileset
+            >>> from geobox.aio.tileset import AsyncTileset
             >>> async with AsyncGeoboxClient() as client:
-            >>>     tileset = await Tileset.get_tileset(client, uuid="12345678-1234-5678-1234-567812345678")
+            >>>     tileset = await AsyncTileset.get_tileset(client, uuid="12345678-1234-5678-1234-567812345678")
             >>>     await tileset.get_shared_users(search='John', skip=0, limit=10)
         """
         params = {
@@ -496,9 +495,9 @@ class Tileset(AsyncBase):
 
         Example:
             >>> from geobox.aio import AsyncGeoboxClient
-            >>> from geobox.aio.tileset import Tileset
+            >>> from geobox.aio.tileset import AsyncTileset
             >>> async with AsyncGeoboxClient() as client:
-            >>>     tileset = await Tileset.get_tileset(client, uuid="12345678-1234-5678-1234-567812345678")
+            >>>     tileset = await AsyncTileset.get_tileset(client, uuid="12345678-1234-5678-1234-567812345678")
             >>>     await tileset.get_tile_json()
         """ 
         endpoint = urljoin(self.endpoint, 'tilejson.json/')
@@ -514,9 +513,9 @@ class Tileset(AsyncBase):
 
         Example:
             >>> from geobox.aio import AsyncGeoboxClient
-            >>> from geobox.aio.tileset import Tileset
+            >>> from geobox.aio.tileset import AsyncTileset
             >>> async with AsyncGeoboxClient() as client:
-            >>>     tileset = await Tileset.get_tileset(client, uuid="12345678-1234-5678-1234-567812345678")
+            >>>     tileset = await AsyncTileset.get_tileset(client, uuid="12345678-1234-5678-1234-567812345678")
             >>>     await tileset.update_tileset_extent()
         """
         endpoint = urljoin(self.endpoint, 'updateExtent/')
@@ -537,9 +536,9 @@ class Tileset(AsyncBase):
 
         Example:
             >>> from geobox.aio import AsyncGeoboxClient
-            >>> from geobox.aio.tileset import Tileset
+            >>> from geobox.aio.tileset import AsyncTileset
             >>> async with AsyncGeoboxClient() as client:
-            >>>     tileset = await Tileset.get_tileset(client, uuid="12345678-1234-5678-1234-567812345678")
+            >>>     tileset = await AsyncTileset.get_tileset(client, uuid="12345678-1234-5678-1234-567812345678")
             >>>     await tileset.get_tile_tileset(x=1, y=1, z=1)
         """
         endpoint = f'{self.api.base_url}{self.endpoint}tiles/{z}/{x}/{y}.pbf'
@@ -550,7 +549,7 @@ class Tileset(AsyncBase):
         return endpoint
 
 
-    async def seed_cache(self, from_zoom: int = 0, to_zoom: int = 14, extent: list = [], workers: int = 1, user_id: int = 0) -> List['Task']:
+    async def seed_cache(self, from_zoom: int = 0, to_zoom: int = 14, extent: list = [], workers: int = 1, user_id: int = 0) -> List['AsyncTask']:
         """
         [async] Seeds the cache of the tileset.
 
@@ -562,16 +561,16 @@ class Tileset(AsyncBase):
             user_id (int, optional): The user ID.
 
         Returns:
-            List[Task]: list of task objects.
+            List[AsyncTask]: list of task objects.
 
         Raises:
             ValueError: If the number of workers is not one of the following: 1, 2, 4, 8, 12, 16, 20, 24.
 
         Example:
             >>> from geobox.aio import AsyncGeoboxClient
-            >>> from geobox.aio.tileset import Tileset
+            >>> from geobox.aio.tileset import AsyncTileset
             >>> async with AsyncGeoboxClient() as client:
-            >>>     tileset = await Tileset.get_tileset(client, uuid="12345678-1234-5678-1234-567812345678")
+            >>>     tileset = await AsyncTileset.get_tileset(client, uuid="12345678-1234-5678-1234-567812345678")
             >>>     await tileset.seed_cache(from_zoom=0, to_zoom=14, extent=[], workers=1)
         """
         data = {
@@ -584,7 +583,7 @@ class Tileset(AsyncBase):
         return await super()._seed_cache(endpoint=self.endpoint, data=data)
 
 
-    async def update_cache(self, from_zoom: int, to_zoom: int, extents: List[List[float]] = None, user_id: int = 0) -> List['Task']:
+    async def update_cache(self, from_zoom: int, to_zoom: int, extents: List[List[float]] = None, user_id: int = 0) -> List['AsyncTask']:
         """
         [async] Updates the cache of the tileset.
 
@@ -599,9 +598,9 @@ class Tileset(AsyncBase):
 
         Example:
             >>> from geobox.aio import AsyncGeoboxClient
-            >>> from geobox.aio.tileset import Tileset
+            >>> from geobox.aio.tileset import AsyncTileset
             >>> async with AsyncGeoboxClient() as client:
-            >>>     tileset = await Tileset.get_tileset(client, uuid="12345678-1234-5678-1234-567812345678")
+            >>>     tileset = await AsyncTileset.get_tileset(client, uuid="12345678-1234-5678-1234-567812345678")
             >>>     await tileset.update_cache(from_zoom=0, to_zoom=14, extent=[])
         """
         data = {
@@ -623,9 +622,9 @@ class Tileset(AsyncBase):
 
         Example:
             >>> from geobox.aio import AsyncGeoboxClient
-            >>> from geobox.aio.tileset import Tileset
+            >>> from geobox.aio.tileset import AsyncTileset
             >>> async with AsyncGeoboxClient() as client:
-            >>>     tileset = await Tileset.get_tileset(client, uuid="12345678-1234-5678-1234-567812345678")
+            >>>     tileset = await AsyncTileset.get_tileset(client, uuid="12345678-1234-5678-1234-567812345678")
             >>>     await tileset.cache_size
         """
         return await super()._cache_size(endpoint=self.endpoint)
@@ -640,33 +639,33 @@ class Tileset(AsyncBase):
 
         Example:
             >>> from geobox.aio import AsyncGeoboxClient
-            >>> from geobox.aio.tileset import Tileset
+            >>> from geobox.aio.tileset import AsyncTileset
             >>> async with AsyncGeoboxClient() as client:
-            >>>     tileset = await Tileset.get_tileset(client, uuid="12345678-1234-5678-1234-567812345678")
+            >>>     tileset = await AsyncTileset.get_tileset(client, uuid="12345678-1234-5678-1234-567812345678")
             >>>     await tileset.clear_cache()
         """
         await super()._clear_cache(endpoint=self.endpoint)
 
 
-    def to_sync(self, sync_client: 'SyncGeoboxClient') -> 'SyncTileset':
+    def to_sync(self, sync_client: 'GeoboxClient') -> 'Tileset':
         """
         Switch to sync version of the tileset instance to have access to the sync methods
 
         Args:
-            sync_client (SyncGeoboxClient): The sync version of the GeoboxClient instance for making requests.
+            sync_client (GeoboxClient): The sync version of the GeoboxClient instance for making requests.
 
         Returns:
-            geobox.tileset.Tileset: the sync instance of the tileset.
+            Tileset: the sync instance of the tileset.
 
         Example:
             >>> from geobox import Geoboxclient
             >>> from geobox.aio import AsyncGeoboxClient
-            >>> from geobox.aio.tileset import Tileset
+            >>> from geobox.aio.tileset import AsyncTileset
             >>> client = GeoboxClient()
             >>> async with AsyncGeoboxClient() as async_client:
-            >>>     tileset = await Tileset.get_tileset(async_client, uuid="12345678-1234-5678-1234-567812345678")
+            >>>     tileset = await AsyncTileset.get_tileset(async_client, uuid="12345678-1234-5678-1234-567812345678")
             >>>     sync_tileset = tileset.to_sync(client)
         """
-        from ..tileset import Tileset as SyncTileset
+        from ..tileset import Tileset
 
-        return SyncTileset(api=sync_client, uuid=self.uuid, data=self.data)
+        return Tileset(api=sync_client, uuid=self.uuid, data=self.data)