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

geobox/aio/raster.py

@@ -1,32 +1,29 @@
 import os
-from urllib.parse import urljoin, urlencode
-from typing import Optional, Dict, List, Optional, Union, TYPE_CHECKING
 import mimetypes
 import requests
 import sys
+from urllib.parse import urljoin, urlencode
+from typing import Optional, Dict, List, Optional, Union, TYPE_CHECKING
 
 from .base import AsyncBase
-from .task import Task
-from .vectorlayer import VectorLayer
-from .view import VectorLayerView
+from .task import AsyncTask
 from ..utils import clean_data, join_url_params
-from ..enums import PolygonizeConnectivity, AnalysisResampleMethod, SlopeUnit, AnalysisAlgorithm, AnalysisDataType, RangeBound, DistanceUnit
 
 if TYPE_CHECKING:
     from . import AsyncGeoboxClient
-    from .user import User
-    from ..api import GeoboxClient as SyncGeoboxClient
-    from ..raster import Raster as SyncRaster
+    from .user import AsyncUser
+    from ..api import GeoboxClient
+    from ..raster import Raster
 
 
-class Raster(AsyncBase):
+class AsyncRaster(AsyncBase):
 
     BASE_ENDPOINT: str = 'rasters/'
 
     def __init__(self,
-                 api: 'AsyncGeoboxClient',
-                 uuid: str,
-                 data: Optional[Dict] = {}):
+        api: 'AsyncGeoboxClient',
+        uuid: str,
+        data: Optional[Dict] = {}):
         """
         Constructs all the necessary attributes for the Raster object.
 
@@ -39,7 +36,7 @@ class Raster(AsyncBase):
 
 
     @classmethod
-    async def get_rasters(cls, api: 'AsyncGeoboxClient', **kwargs) -> Union[List['Raster'], int]:
+    async def get_rasters(cls, api: 'AsyncGeoboxClient', **kwargs) -> Union[List['AsyncRaster'], int]:
         """
         [async] Get all rasters.
 
@@ -59,13 +56,13 @@ class Raster(AsyncBase):
             shared (bool): whether to return shared rasters. default is False.
 
         Returns:
-            List[Raster] | int: A list of Raster objects or the total count of rasters.
+            List[AsyncRaster] | int: A list of Raster objects or the total count of rasters.
 
         Example:
             >>> from geobox.aio import AsyncGeoboxClient
-            >>> from geobox.aio.raster import Raster
+            >>> from geobox.aio.raster import AsyncRaster
             >>> async with AsyncGeoboxClient() as client:
-            >>>     rasters = await Raster.get_rasters(client, terrain=True, q="name LIKE '%GIS%'")
+            >>>     rasters = await AsyncRaster.get_rasters(client, terrain=True, q="name LIKE '%GIS%'")
             or  
             >>>     rasters = await client.get_rasters(terrain=True, q="name LIKE '%GIS%'")
         """
@@ -82,12 +79,12 @@ class Raster(AsyncBase):
             'user_id': kwargs.get('user_id', None),
             'shared': kwargs.get('shared', False)
         }
-        return await super()._get_list(api, cls.BASE_ENDPOINT, params, factory_func=lambda api, item: Raster(api, item['uuid'], item))
+        return await super()._get_list(api, cls.BASE_ENDPOINT, params, factory_func=lambda api, item: AsyncRaster(api, item['uuid'], item))
     
 
 
     @classmethod
-    async def get_rasters_by_ids(cls, api: 'AsyncGeoboxClient', ids: List[str], user_id: int = None) -> List['Raster']:
+    async def get_rasters_by_ids(cls, api: 'AsyncGeoboxClient', ids: List[str], user_id: int = None) -> List['AsyncRaster']:
         """
         [async] Get rasters by their IDs.
 
@@ -97,13 +94,13 @@ class Raster(AsyncBase):
             user_id (int, optional): specific user. privileges required.
 
         Returns:
-            List['Raster']: A list of Raster objects.
+            List['AsyncRaster']: A list of Raster objects.
 
         Example:
             >>> from geobox.aio import AsyncGeoboxClient
-            >>> from geobox.aio.raster import Raster
+            >>> from geobox.aio.raster import AsyncRaster
             >>> async with AsyncGeoboxClient() as client:
-            >>>     rasters = await Raster.get_rasters_by_ids(client, ids=['123', '456'])
+            >>>     rasters = await AsyncRaster.get_rasters_by_ids(client, ids=['123', '456'])
             or  
             >>>     rasters = await client.get_rasters_by_ids(ids=['123', '456'])
         """ 
@@ -113,11 +110,11 @@ class Raster(AsyncBase):
         }
         endpoint = urljoin(cls.BASE_ENDPOINT, 'get-rasters/')
 
-        return await super()._get_list_by_ids(api, endpoint, params, factory_func=lambda api, item: Raster(api, item['uuid'], item))
+        return await super()._get_list_by_ids(api, endpoint, params, factory_func=lambda api, item: AsyncRaster(api, item['uuid'], item))
 
 
     @classmethod
-    async def get_raster(cls, api: 'AsyncGeoboxClient', uuid: str, user_id: int = None) -> 'Raster':
+    async def get_raster(cls, api: 'AsyncGeoboxClient', uuid: str, user_id: int = None) -> 'AsyncRaster':
         """
         [async] Get a raster by its UUID.
 
@@ -127,13 +124,13 @@ class Raster(AsyncBase):
             user_id (int, optional): specific user. privileges required.
 
         Returns:
-            Raster: A Raster object.
+            AsyncRaster: A Raster object.
 
         Example:
             >>> from geobox.aio import AsyncGeoboxClient
-            >>> from geobox.aio.raster import Raster
+            >>> from geobox.aio.raster import AsyncRaster
             >>> async with AsyncGeoboxClient() as client:
-            >>>     raster = await Raster.get_raster(client, uuid="12345678-1234-5678-1234-567812345678")
+            >>>     raster = await AsyncRaster.get_raster(client, uuid="12345678-1234-5678-1234-567812345678")
             or  
             >>>     raster = await client.get_raster(uuid="12345678-1234-5678-1234-567812345678")
         """
@@ -141,11 +138,11 @@ class Raster(AsyncBase):
             'f': 'json',
             'user_id': user_id
         }
-        return await super()._get_detail(api, cls.BASE_ENDPOINT, uuid, params, factory_func=lambda api, item: Raster(api, item['uuid'], item))
+        return await super()._get_detail(api, cls.BASE_ENDPOINT, uuid, params, factory_func=lambda api, item: AsyncRaster(api, item['uuid'], item))
 
 
     @classmethod
-    async def get_raster_by_name(cls, api: 'AsyncGeoboxClient', name: str, user_id: int = None) -> Union['Raster', None]:
+    async def get_raster_by_name(cls, api: 'AsyncGeoboxClient', name: str, user_id: int = None) -> Union['AsyncRaster', None]:
         """
         [async] Get a raster by name
 
@@ -155,13 +152,13 @@ class Raster(AsyncBase):
             user_id (int, optional): specific user. privileges required.
 
         Returns:
-            Raster | None: returns the raster if a raster matches the given name, else None
+            AsyncRaster | None: returns the raster if a raster matches the given name, else None
 
         Example:
             >>> from geobox.aio import AsyncGeoboxClient
-            >>> from geobox.aio.raster import Raster
+            >>> from geobox.aio.raster import AsyncRaster
             >>> async with AsyncGeoboxClient() as client:
-            >>>     raster = await Raster.get_raster_by_name(client, name='test')
+            >>>     raster = await AsyncRaster.get_raster_by_name(client, name='test')
             or  
             >>>     raster = await client.get_raster_by_name(name='test')
         """
@@ -186,9 +183,9 @@ class Raster(AsyncBase):
 
         Example:
             >>> from geobox.aio import AsyncGeoboxClient
-            >>> from geobox.aio.raster import Raster
+            >>> from geobox.aio.raster import AsyncRaster
             >>> async with AsyncGeoboxClient() as client:
-            >>>     raster = await Raster.get_raster(client, uuid="12345678-1234-5678-1234-567812345678")
+            >>>     raster = await AsyncRaster.get_raster(client, uuid="12345678-1234-5678-1234-567812345678")
             >>>     await raster.update(name="new_name")
         """ 
         params = {
@@ -208,12 +205,12 @@ class Raster(AsyncBase):
 
         Example:
             >>> from geobox.aio import AsyncGeoboxClient
-            >>> from geobox.aio.raster import Raster
+            >>> from geobox.aio.raster import AsyncRaster
             >>> async with AsyncGeoboxClient() as client:
-            >>>     raster = await Raster.get_raster(client, uuid="12345678-1234-5678-1234-567812345678")
+            >>>     raster = await AsyncRaster.get_raster(client, uuid="12345678-1234-5678-1234-567812345678")
             >>>     await raster.delete()
         """
-        await super().delete(self.endpoint)
+        await super()._delete(self.endpoint)
     
 
     @property
@@ -226,12 +223,12 @@ class Raster(AsyncBase):
 
         Example:
             >>> from geobox.aio import AsyncGeoboxClient
-            >>> from geobox.aio.raster import Raster
+            >>> from geobox.aio.raster import AsyncRaster
             >>> async with AsyncGeoboxClient() as client:
-            >>>     raster = await Raster.get_raster(client, uuid="12345678-1234-5678-1234-567812345678")
+            >>>     raster = await AsyncRaster.get_raster(client, uuid="12345678-1234-5678-1234-567812345678")
             >>>     raster.thumbnail
         """
-        return super().thumbnail(format='')
+        return super()._thumbnail(format='')
     
     
     @property
@@ -244,9 +241,9 @@ class Raster(AsyncBase):
 
         Example:
             >>> from geobox.aio import AsyncGeoboxClient
-            >>> from geobox.aio.raster import Raster
+            >>> from geobox.aio.raster import AsyncRaster
             >>> async with AsyncGeoboxClient() as client:
-            >>>     raster = await Raster.get_raster(client, uuid="12345678-1234-5678-1234-567812345678")
+            >>>     raster = await AsyncRaster.get_raster(client, uuid="12345678-1234-5678-1234-567812345678")
             >>>     await raster.info
         """
         endpoint = urljoin(self.endpoint, 'info/')
@@ -265,9 +262,9 @@ class Raster(AsyncBase):
 
         Example:
             >>> from geobox.aio import AsyncGeoboxClient
-            >>> from geobox.aio.raster import Raster
+            >>> from geobox.aio.raster import AsyncRaster
             >>> async with AsyncGeoboxClient() as client:
-            >>>     raster = await Raster.get_raster(client, uuid="12345678-1234-5678-1234-567812345678")
+            >>>     raster = await AsyncRaster.get_raster(client, uuid="12345678-1234-5678-1234-567812345678")
             >>>     await raster.get_statistics(indexes='1, 2, 3')
         """
         params = clean_data({
@@ -291,9 +288,9 @@ class Raster(AsyncBase):
 
         Example:
             >>> from geobox.aio import AsyncGeoboxClient
-            >>> from geobox.aio.raster import Raster
+            >>> from geobox.aio.raster import AsyncRaster
             >>> async with AsyncGeoboxClient() as client:
-            >>>     raster = await Raster.get_raster(client, uuid="12345678-1234-5678-1234-567812345678")
+            >>>     raster = await AsyncRaster.get_raster(client, uuid="12345678-1234-5678-1234-567812345678")
             >>>     await raster.get_point(lat=60, lng=50)
         """
         if lat < -90 or lat > 90:
@@ -392,9 +389,9 @@ class Raster(AsyncBase):
 
         Example:
             >>> from geobox.aio import AsyncGeoboxClient
-            >>> from geobox.aio.raster import Raster
+            >>> from geobox.aio.raster import AsyncRaster
             >>> async with AsyncGeoboxClient() as client:
-            >>>     raster = await Raster.get_raster(client, uuid="12345678-1234-5678-1234-567812345678")
+            >>>     raster = await AsyncRaster.get_raster(client, uuid="12345678-1234-5678-1234-567812345678")
             >>>     await raster.download(save_path="path/to/save/")
         """
         if not self.uuid:
@@ -440,9 +437,9 @@ class Raster(AsyncBase):
 
         Examples:
             >>> from geobox.aio import AsyncGeoboxClient
-            >>> from geobox.aio.raster import Raster
+            >>> from geobox.aio.raster import AsyncRaster
             >>> async with AsyncGeoboxClient() as client:
-            >>>     raster = await Raster.get_raster(client, uuid="12345678-1234-5678-1234-567812345678")
+            >>>     raster = await AsyncRaster.get_raster(client, uuid="12345678-1234-5678-1234-567812345678")
             >>>     raster_tiff = await raste.get_content_file()
         """
         if not self.uuid:
@@ -492,9 +489,9 @@ class Raster(AsyncBase):
 
         Example:
             >>> from geobox.aio import AsyncGeoboxClient
-            >>> from geobox.aio.raster import Raster
+            >>> from geobox.aio.raster import AsyncRaster
             >>> async with AsyncGeoboxClient() as client:
-            >>>     raster = await Raster.get_raster(client, uuid="12345678-1234-5678-1234-567812345678")
+            >>>     raster = await AsyncRaster.get_raster(client, uuid="12345678-1234-5678-1234-567812345678")
             >>>     raster.get_tile_render_url(x=10, y=20, z=1)
         """
         params = clean_data({
@@ -532,9 +529,9 @@ class Raster(AsyncBase):
 
         Example:
             >>> from geobox.aio import AsyncGeoboxClient
-            >>> from geobox.aio.raster import Raster
+            >>> from geobox.aio.raster import AsyncRaster
             >>> async with AsyncGeoboxClient() as client:
-            >>>     raster = await Raster.get_raster(client, uuid="12345678-1234-5678-1234-567812345678")
+            >>>     raster = await AsyncRaster.get_raster(client, uuid="12345678-1234-5678-1234-567812345678")
             >>>     raster.get_tile_pbf_url(x=10, y=20, z=1)
         """
         params = clean_data({
@@ -564,9 +561,9 @@ class Raster(AsyncBase):
 
         Example:
             >>> from geobox.aio import AsyncGeoboxClient
-            >>> from geobox.aio.raster import Raster
+            >>> from geobox.aio.raster import AsyncRaster
             >>> async with AsyncGeoboxClient() as client:
-            >>>     raster = await Raster.get_raster(client, uuid="12345678-1234-5678-1234-567812345678")
+            >>>     raster = await AsyncRaster.get_raster(client, uuid="12345678-1234-5678-1234-567812345678")
             >>>     raster.get_tile_png_url(x=10, y=20, z=1)
         """
         endpoint = f'{self.api.base_url}{self.endpoint}tiles/{z}/{x}/{y}.png'
@@ -586,9 +583,9 @@ class Raster(AsyncBase):
 
         Example:
             >>> from geobox.aio import AsyncGeoboxClient
-            >>> from geobox.aio.raster import Raster
+            >>> from geobox.aio.raster import AsyncRaster
             >>> async with AsyncGeoboxClient() as client:
-            >>>     raster = await Raster.get_raster(client, uuid="12345678-1234-5678-1234-567812345678")
+            >>>     raster = await AsyncRaster.get_raster(client, uuid="12345678-1234-5678-1234-567812345678")
             >>>     await raster.get_tile_json()
         """
         endpoint = urljoin(self.endpoint, 'tilejson.json')
@@ -607,9 +604,9 @@ class Raster(AsyncBase):
 
         Example:
             >>> from geobox.aio import AsyncGeoboxClient
-            >>> from geobox.aio.raster import Raster
+            >>> from geobox.aio.raster import AsyncRaster
             >>> async with AsyncGeoboxClient() as client:
-            >>>     raster = await Raster.get_raster(client, uuid="12345678-1234-5678-1234-567812345678")
+            >>>     raster = await AsyncRaster.get_raster(client, uuid="12345678-1234-5678-1234-567812345678")
             >>>     raster.wmts(scale=1)
         """ 
         endpoint = urljoin(self.api.base_url, f'{self.endpoint}wmts/')
@@ -632,9 +629,9 @@ class Raster(AsyncBase):
 
         Example:
             >>> from geobox.aio import AsyncGeoboxClient
-            >>> from geobox.aio.raster import Raster
+            >>> from geobox.aio.raster import AsyncRaster
             >>> async with AsyncGeoboxClient() as client:
-            >>>     raster = await Raster.get_raster(client, uuid="12345678-1234-5678-1234-567812345678")
+            >>>     raster = await AsyncRaster.get_raster(client, uuid="12345678-1234-5678-1234-567812345678")
             >>>     await raster.settings
         """
         return await super()._get_settings(self.endpoint)
@@ -679,9 +676,9 @@ class Raster(AsyncBase):
 
         Example:
             >>> from geobox.aio import AsyncGeoboxClient
-            >>> from geobox.aio.raster import Raster
+            >>> from geobox.aio.raster import AsyncRaster
             >>> async with AsyncGeoboxClient() as client:
-            >>>     raster = await Raster.get_raster(client, uuid="12345678-1234-5678-1234-567812345678")
+            >>>     raster = await AsyncRaster.get_raster(client, uuid="12345678-1234-5678-1234-567812345678")
             >>>     await raster.set_settings(nodata=0, 
             ...                             indexes=[1], 
             ...                             rescale=[[0, 10000]], 
@@ -714,49 +711,49 @@ class Raster(AsyncBase):
         return await super()._set_settings(self.endpoint, settings)
 
 
-    async def share(self, users: List['User']) -> None:
+    async def share(self, users: List['AsyncUser']) -> None:
         """
         [async] Shares the raster with specified users.
 
         Args:
-            users (List[User]): The list of user objects to share the raster with.
+            users (List[AsyncUser]): The list of user objects to share the raster with.
 
         Returns:
             None
 
         Example:
             >>> from geobox.aio import AsyncGeoboxClient
-            >>> from geobox.aio.raster import Raster
+            >>> from geobox.aio.raster import AsyncRaster
             >>> async with AsyncGeoboxClient() as client:
-            >>>     raster = await Raster.get_raster(client, uuid="12345678-1234-5678-1234-567812345678")
+            >>>     raster = await AsyncRaster.get_raster(client, uuid="12345678-1234-5678-1234-567812345678")
             >>>     users = await client.search_users(search="John")
             >>>     await raster.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 raster with specified users.
 
         Args:
-            users (List[User]): The list of user objects to unshare the raster with.
+            users (List[AsyncUser]): The list of user objects to unshare the raster with.
 
         Returns:
             None
 
         Example:
             >>> from geobox.aio import AsyncGeoboxClient
-            >>> from geobox.aio.raster import Raster
+            >>> from geobox.aio.raster import AsyncRaster
             >>> async with AsyncGeoboxClient() as client:
-            >>>     raster = await Raster.get_raster(client, uuid="12345678-1234-5678-1234-567812345678")
+            >>>     raster = await AsyncRaster.get_raster(client, uuid="12345678-1234-5678-1234-567812345678")
             >>>     users = await client.search_users(search="John")
             >>>     await raster.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 raster is shared with.
 
@@ -766,13 +763,13 @@ class Raster(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.raster import Raster
+            >>> from geobox.aio.raster import AsyncRaster
             >>> async with AsyncGeoboxClient() as client:
-            >>>     raster = await Raster.get_raster(client, uuid="12345678-1234-5678-1234-567812345678")
+            >>>     raster = await AsyncRaster.get_raster(client, uuid="12345678-1234-5678-1234-567812345678")
             >>>     await raster.get_shared_users(search='John', skip=0, limit=10)
         """
         params = {
@@ -783,7 +780,7 @@ class Raster(AsyncBase):
         return await super()._get_shared_users(self.endpoint, params)
 
 
-    async def seed_cache(self, from_zoom: int = None, to_zoom: int = None, extent: List[int] = None, workers: int = 1) -> List['Task']:
+    async def seed_cache(self, from_zoom: int = None, to_zoom: int = None, extent: List[int] = None, workers: int = 1) -> List['AsyncTask']:
         """
         [async] Seed the cache of the raster.
 
@@ -794,13 +791,13 @@ class Raster(AsyncBase):
             workers (int, optional): The number of workers to use. default is 1.
 
         Returns:
-            Task: The task of the seed cache.
+            AsyncTask: The task of the seed cache.
 
         Example:
             >>> from geobox.aio import AsyncGeoboxClient
-            >>> from geobox.aio.raster import Raster
+            >>> from geobox.aio.raster import AsyncRaster
             >>> async with AsyncGeoboxClient() as client:
-            >>>     raster = await Raster.get_raster(client, uuid="12345678-1234-5678-1234-567812345678")
+            >>>     raster = await AsyncRaster.get_raster(client, uuid="12345678-1234-5678-1234-567812345678")
             >>>     task = await raster.seed_cache(from_zoom=0, to_zoom=22, extent=[0, 0, 100, 100], workers=1)
         """
         data = {
@@ -821,9 +818,9 @@ class Raster(AsyncBase):
 
         Example:
             >>> from geobox.aio import AsyncGeoboxClient
-            >>> from geobox.aio.raster import Raster
+            >>> from geobox.aio.raster import AsyncRaster
             >>> async with AsyncGeoboxClient() as client:
-            >>>     raster = await Raster.get_raster(client, uuid="12345678-1234-5678-1234-567812345678")
+            >>>     raster = await AsyncRaster.get_raster(client, uuid="12345678-1234-5678-1234-567812345678")
             >>>     await raster.clear_cache()
         """
         await super()._clear_cache(self.endpoint)
@@ -839,399 +836,36 @@ class Raster(AsyncBase):
 
         Example:
             >>> from geobox.aio import AsyncGeoboxClient
-            >>> from geobox.aio.raster import Raster
+            >>> from geobox.aio.raster import AsyncRaster
             >>> async with AsyncGeoboxClient() as client:
-            >>>     raster = await Raster.get_raster(client, uuid="12345678-1234-5678-1234-567812345678")
+            >>>     raster = await AsyncRaster.get_raster(client, uuid="12345678-1234-5678-1234-567812345678")
             >>>     await raster.cache_size
         """
         return await super()._cache_size(self.endpoint)
 
 
-    def to_sync(self, sync_client: 'SyncGeoboxClient') -> 'SyncRaster':
+    def to_sync(self, sync_client: 'GeoboxClient') -> 'Raster':
         """
         Switch to sync version of the raster 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.raster.Raster: the sync instance of the raster.
+            Raster: the sync instance of the raster.
 
         Example:
             >>> from geobox import Geoboxclient
             >>> from geobox.aio import AsyncGeoboxClient
-            >>> from geobox.aio.raster import Raster
+            >>> from geobox.aio.raster import AsyncRaster
             >>> client = GeoboxClient()
             >>> async with AsyncGeoboxClient() as async_client:
-            >>>     raster = await Raster.get_raster(async_client, uuid="12345678-1234-5678-1234-567812345678")
+            >>>     raster = await AsyncRaster.get_raster(async_client, uuid="12345678-1234-5678-1234-567812345678")
             >>>     sync_raster = raster.to_sync(client)
         """
-        from ..raster import Raster as SyncRaster
-
-        return SyncRaster(api=sync_client, uuid=self.uuid, data=self.data)
-
-
-    async def polygonize(self,
-        output_layer_name: str,
-        band_index: int = 1,
-        value_field: Optional[str] = None,
-        mask_nodata: bool = False,
-        connectivity: PolygonizeConnectivity = PolygonizeConnectivity.connected_4,
-        keep_values: Optional[str] = None,
-        layer_name: Optional[str] = None,
-        user_id: Optional[int] = None) -> 'Task':
-        """
-        [async] Convert a raster to vector polygons
-
-        vectorizes a raster (polygonize) to a vector dataset (*.gpkg). Only users with Publisher role or higher can perform this operation
-
-        Args:
-            api (GeoboxClient): The GeoboxClient instance for making requests
-            raster (Raster): Raster instance
-            output_layer_name  (str): Name for the output vector layer.
-            band_index (int, optional): Raster band to polygonize. default: 1
-            value_field (str, optional): Name of attribute field storing the pixel value. default: None
-            mask_nodata (bool, optional): If True, NoData pixels are excluded using the band mask. default: False
-            connectivity (PolygonizeConnectivity, optional): 4 or 8 connectivity for region grouping. default: PolygonizeConnectivity.connected_4 
-            keep_values (str, optional): JSON array of values to keep (e.g., '[1,2,3]'). default: None
-            layer_name (str, optional): Output layer name. default: None
-            user_id (int, optional): specific user. priviledges required!
-
-        Returns:
-            Task: task instance of the process
-
-        Example:
-            >>> from geobox.aio import AsyncGeoboxClient
-            >>> async with AsyncGeoboxClient() as client:
-            >>>     raster = await client.get_raster(uuid="12345678-1234-5678-1234-567812345678")
-            >>>     task = raster.polygonize(output_layer_name='test')
-        """
-        from .analysis import Analysis
-        return await Analysis.polygonize(self.api,
-            self,
-            output_layer_name=output_layer_name,
-            band_index=band_index,
-            value_field=value_field,
-            mask_nodata=mask_nodata,
-            connectivity=connectivity,
-            keep_values=keep_values,
-            layer_name=layer_name,
-            user_id=user_id)
-
-
-    async def clip(self,
-        layer: Union[VectorLayer, VectorLayerView],
-        output_raster_name: str,
-        where: Optional[str] = None,
-        dst_nodata: int = -9999,
-        crop: bool = True,
-        resample: AnalysisResampleMethod = AnalysisResampleMethod.near,
-        user_id: Optional[int] = None) -> 'Task':
-        """
-        [async] Clip a raster using a vector layer as a mask
-
-        clips a raster dataset using a vector layer as the clipping boundary. Only users with Publisher role or higher can perform this operation
-
-        Args:
-            api (GeoboxClient): The GeoboxClient instance for making requests
-            raster (Raster): Raster instance
-            layer (VectorLayer | VectorLayerView): VectorLayer or VectorLayerView instance
-            output_raster_name (str): Name for the output raster dataset
-            where (str, optional): Optional attribute filter, e.g. 'VEG=forest'.
-            dst_nodata (int, optional): Output NoData value. default: -9999
-            crop (bool, optional): True=shrink extent to polygon(s); False=keep full extent but mask outside. default: True
-            resample (AnalysisResampleMethod, optional): Resampling method: 'near', 'bilinear', 'cubic', 'lanczos', etc. default: AnalysisResampleMethod.near
-            user_id (int, optional): specific user. priviledges required!
-
-        Returns:
-            Task: task instance of the process
-
-        Example:
-            >>> from geobox.aio import AsyncGeoboxClient
-            >>> async with AsyncGeoboxClient() as client:
-            >>>     raster = await client.get_raster(uuid="12345678-1234-5678-1234-567812345678")
-            >>>     vector = await client.get_vector(uuid="12345678-1234-5678-1234-567812345678")
-            >>>     await raster.clip(layer=vector, output_raster_name='test')
-        """
-        from .analysis import Analysis
-        return await Analysis.clip(self.api,
-            self,
-            layer=layer,
-            output_raster_name=output_raster_name,
-            where=where,
-            dst_nodata=dst_nodata,
-            crop=crop,
-            resample=resample,
-            user_id=user_id)
-
-
-    async def slope(self,
-        output_raster_name: str,
-        slope_units: SlopeUnit = SlopeUnit.degree,
-        algorithm: AnalysisAlgorithm = AnalysisAlgorithm.Horn,
-        scale: int = 1,
-        compute_edges: bool = True,
-        nodata_out: int = -9999,
-        user_id: Optional[int] = None) -> 'Task':
-        """
-        [async] Calculate slope from a DEM raster.
-
-        This endpoint creates a slope raster from a Digital Elevation Model (DEM). Only users with Publisher role or higher can perform this operation.
-
-        Args:
-            output_raster_name (str): Name for the output raster dataset.
-            slope_units (SlopeUnit, optional): Slope units: 'degree' or 'percent'. default: SlopeUnit.degree
-            algorithm (AnalysisAlgorithm, optional): Algorithm: 'Horn' or 'ZevenbergenThorne'. default: AnalysisAlgorithm.Horn
-            scale (int, optional): Ratio of vertical units to horizontal units. default: 1
-            compute_edges (bool, optional): Whether to compute edges. default: True
-            nodata (int, optional): NoData value for the output raster. default = -9999
-            user_id (int, optional): specific user. priviledges required!
-
-        Returns:
-            Task: task instance of the process
-
-        Example:
-            >>> from geobox.aio import AsyncGeoboxClient
-            >>> async with AsyncGeoboxClient() as client:
-            >>>     raster = await client.get_raster(uuid="12345678-1234-5678-1234-567812345678")
-            >>>     task = await raster.slope(output_raster_name='test')
-        """
-        from .analysis import Analysis
-        return await Analysis.slope(self.api,
-            self,
-            slope_units=slope_units,
-            output_raster_name=output_raster_name,
-            algorithm=algorithm,
-            scale=scale,
-            compute_edges=compute_edges,
-            nodata_out=nodata_out,
-            user_id=user_id)
-
-
-    async def aspect(self,
-        output_raster_name: str,
-        algorithm: AnalysisAlgorithm = AnalysisAlgorithm.Horn,
-        trigonometric: bool = False,
-        zero_for_flat: bool = True,
-        compute_edges: bool = True,
-        nodata_out: int = -9999,
-        user_id: Optional[int] = None) -> 'Task':
-        """
-        [async] Calculate aspect from a DEM raster.
-
-        it creates an aspect raster (degrees 0–360) from a Digital Elevation Model (DEM).
-        Only users with Publisher role or higher can perform this operation.
-
-        Args:
-            api (GeoboxClient): The GeoboxClient instance for making requests
-            raster (Raster): DEM Raster instance
-            output_raster_name (str): Name for the output raster dataset.
-            algorithm (AnalysisAlgorithm, optional): Algorithm: 'Horn' or 'ZevenbergenThorne'. default: AnalysisAlgorithm.Horn
-            trigonometric (bool, optional): False: azimuth (0°=N, 90°=E, clockwise); True: 0°=E, counter-clockwise. default: False
-            zero_for_flat (bool, optional): Set flats (slope==0) to 0 instead of NoData. default: True
-            compute_edges (bool, optional): Whether to compute edges. default: True
-            nodata (int, optional): NoData value for the output raster. default = -9999
-            user_id (int, optional): specific user. priviledges required!
-
-        Returns:
-            Task: task instance of the process
-
-        Example:
-            >>> from geobox.aio import AsyncGeoboxClient
-            >>> async with AsyncGeoboxClient() as client:
-            >>>     raster = await client.get_raster(uuid="12345678-1234-5678-1234-567812345678")
-            >>>     await raster.aspect(output_raster_name='test')
-        """
-        from .analysis import Analysis
-        return await Analysis.aspect(self.api,
-            self,
-            output_raster_name=output_raster_name,
-            algorithm=algorithm,
-            trigonometric=trigonometric,
-            zero_for_flat=zero_for_flat,
-            compute_edge=compute_edges,
-            nodata_out=nodata_out,
-            user_id=user_id)
-
-
-    async def reclassify(self,
-        output_raster_name: str,
-        rules: str,
-        default_value: Optional[int] = None,
-        nodata_in: int = -9999,
-        nodata_out: int = -9999,
-        out_dtype: AnalysisDataType = AnalysisDataType.int16,
-        inclusive: RangeBound = RangeBound.left,
-        user_id: Optional[int] = None) -> 'Task':
-        """
-        [async] Reclassify a raster using value mapping or class breaks.
-
-        This endpoint reclassifies raster values according to specified rules. 
-        Only users with Publisher role or higher can perform this operation.
-
-        Args:
-            output_raster_name (str): Name for the output reclassified raster dataset.
-            rules (str): JSON string containing reclassification rules. 
-                            For mode='exact', it should be a dict {old_value: new_value}. 
-                            For mode='range', it should be a list of (low, high, new_value). 
-                            Example for mode='exact': '{"1": 10, "2": 20, "3": 30}'. 
-                            Example for mode='range': '[[0, 10, 1], [10, 20, 2], [20, 30, 3]]'.
-                            the method would detect the mode type based on the rules input.
-            default_value (str, optional): Value to assign when a pixel matches no rule.
-            nodata_in (int, optional): NoData of input. If None, tries to get from the input raster.
-            nodata_out (int, optional): NoData value to set on output band.
-            out_dtype (AnalysisDataType, optional): Output data type. default: AnalysisDataType.int16
-            inclusive (RangeBound, optional): Range bound semantics for mode='range': 'left', 'right', 'both', 'neither'. default: RangeBound.left
-            user_id (int, optional): specific user. priviledges required!
-
-        Returns:
-            Task: task instance of the process
-
-        Example:
-            >>> from geobox.aio import AsyncGeoboxClient
-            >>> async with AsyncGeoboxClient() as client:
-            >>>     raster = await client.get_raster(uuid="12345678-1234-5678-1234-567812345678")
-            >>>     await raster.reclassify(output_raster_name='test', rules='{"1": 10, "2": 20, "3": 30}')
-        """
-        from .analysis import Analysis
-        return await Analysis.reclassify(self.api,
-            self,
-            output_raster_name=output_raster_name,
-            rules=rules,
-            default_value=default_value,
-            nodata_in=nodata_in,
-            nodata_out=nodata_out,
-            out_dtype=out_dtype,
-            inclusive=inclusive,
-            user_id=user_id)
-
-
-    async def resample(self,
-        output_raster_name: str,
-        out_res: Optional[str] = None,
-        scale_factor: Optional[str] = None,
-        match_raster_uuid: Optional[str] = None,
-        resample_method: AnalysisResampleMethod = AnalysisResampleMethod.near,
-        dst_nodata: int = -9999,
-        user_id: Optional[int] = None) -> 'Task':
-        """
-        [async] Resample a raster to a different resolution.
-
-        it resamples a raster using GDAL Warp. 
-        Exactly one of out_res, scale_factor, or match_raster_uuid must be provided. 
-        Only users with Publisher role or higher can perform this operation.
-
-        Args:
-            output_raster_name (str): Name for the output reclassified raster dataset.
-            out_res (str, optional): Output resolution as 'x_res,y_res' (e.g., '10,10').
-            scale_factor (int, optional): Scale factor (e.g., 2.0 for 2x finer resolution).
-            match_raster_uuid (str, optional): UUID of reference raster to match resolution/extent.
-            resample_method (AnalysisResampleMethod, optional): Resampling method: 'near', 'bilinear', 'cubic', 'lanczos', etc.
-            dst_nodata (int, optional): Output NoData value.
-            user_id (int, optional): specific user. priviledges required!
+        from ..raster import Raster
 
-        Returns:
-            Task: task instance of the process
-
-        Example:
-            >>> from geobox.aio import AsyncGeoboxClient
-            >>> async with AsyncGeoboxClient() as client:
-            >>>     raster = await client.get_raster(uuid="12345678-1234-5678-1234-567812345678")
-            >>>     await raster.resample(output_raster_name='test')
-        """
-        from .analysis import Analysis
-        return await Analysis.resample(self.api,
-            self,
-            output_raster_name=output_raster_name,
-            out_res=out_res,
-            scale_factor=scale_factor,
-            match_raster_uuid=match_raster_uuid,
-            resample_method=resample_method,
-            dst_nodata=dst_nodata,
-            user_id=user_id)
-
-
-    async def fill_nodata(self,
-        output_raster_name: str,
-        band: Union[int, str] = 1,
-        nodata: Optional[int] = None,
-        max_search_dist: Optional[int] = None,
-        smoothing_iterations: Optional[int] = None,
-        mask_raster_uuid: Optional[str] = None,
-        user_id: Optional[int] = None) -> 'Task':
-        """
-        [async] Fill NoData regions in a raster using GDAL's FillNodata algorithm.
-
-        it fills gaps (NoData regions) in a raster by interpolating values from surrounding valid pixels. 
-        This is commonly used for data cleaning and gap filling in remote sensing and elevation data. 
-        Only users with Publisher role or higher can perform this operation.
-
-        Args:
-            output_raster_name (str): Name for the output filled raster dataset.
-            band (int | str): 1-based band index to process or 'all' to process all bands. default: 1
-            nodata (int, optional): NoData value to use. If None, uses the band's existing NoData.
-            max_search_dist (int, optoinal): Maximum distance in pixels to search for valid data.
-            smoothing_iterations (int, optional): Number of smoothing iterations to apply.
-            mask_raster_uuid (str, optional): Optional UUID of a mask raster (0=masked, >0=valid).
-            user_id (int, optional): specific user. priviledges required!
-
-        Returns:
-            Task: task instance of the process
-
-        Example:
-            >>> from geobox.aio import AsyncGeoboxClient
-            >>> async with AsyncGeoboxClient() as client:
-            >>>     raster = await client.get_raster(uuid="12345678-1234-5678-1234-567812345678")
-            >>>     task = await raster.fill_nodata(output_raster_name='test')
-        """
-        from .analysis import Analysis
-        return await Analysis.fill_nodata(self.api,
-            self,
-            output_raster_name=output_raster_name,
-            band=band,
-            nodata=nodata,
-            max_search_dist=max_search_dist,
-            smoothing_iterations=smoothing_iterations,
-            mask_raster_uuid=mask_raster_uuid,
-            user_id=user_id)
-
-
-    async def proximity(self,
-        output_raster_name: str,
-        dist_units: DistanceUnit = DistanceUnit.GEO,
-        burn_value: int = 1,
-        nodata: int = -9999,
-        user_id: Optional[int] = None) -> 'Task':
-        """
-        [async] Create a proximity (distance) raster from a raster layer.
-
-        it creates a raster showing the distance from each pixel to the nearest pixel in the input raster layer. 
-        Only users with Publisher role or higher can perform this operation.
-
-        Args:
-            output_raster_name (str): Name for the output proximity raster dataset.
-            dist_units (DistanceUnit, optional): Distance units: 'GEO' for georeferenced units, 'PIXEL' for pixels. default: DistanceUnit.GEO
-            burn_value (int, optional): Value treated as targets (distance 0). default: 1
-            nodata (int, optional): NoData value to use in the output raster. default: -9999
-            user_id (int, optional): specific user. priviledges required!
-
-        Returns:
-            Task: task instance of the process
-
-        Example:
-            >>> from geobox.aio import AsyncGeoboxClient
-            >>> async with AsyncGeoboxClient() as client:
-            >>>     raster = await client.get_raster(uuid="12345678-1234-5678-1234-567812345678")
-            >>>     task = await raster.proximity(output_raster_name='test')
-        """
-        from .analysis import Analysis
-        return await Analysis.proximity(self.api,
-            self,
-            output_raster_name=output_raster_name,
-            dist_units=dist_units,
-            burn_value=burn_value,
-            nodata=nodata,
-            user_id=user_id)
+        return Raster(api=sync_client, uuid=self.uuid, data=self.data)
 
 
     async def profile(self,