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

geobox/aio/{analysis.py → raster_analysis.py}

@@ -1,26 +1,26 @@
-from typing import List, Dict, Optional, TYPE_CHECKING, Union
+from typing import Dict, Optional, TYPE_CHECKING, Union
 
 from geobox.field import Field
 
-from .vectorlayer import VectorLayer
-from .view import VectorLayerView
+from .vectorlayer import AsyncVectorLayer
+from .view import AsyncVectorLayerView
 from .base import AsyncBase
-from .raster import Raster
+from .raster import AsyncRaster
 from ..enums import (AnalysisDataType, PolygonizeConnectivity, AnalysisResampleMethod, 
                     SlopeUnit, AnalysisAlgorithm, RangeBound, DistanceUnit)
 from ..utils import clean_data
 
 if TYPE_CHECKING:
     from . import AsyncGeoboxClient
-    from .task import Task
+    from .task import AsyncTask
 
-class Analysis(AsyncBase):
+class AsyncRasterAnalysis(AsyncBase):
 
     BASE_ENDPOINT = 'analysis/'
 
     def __init__(self, 
-                 api: 'AsyncGeoboxClient', 
-                 data: Optional[Dict] = {}):
+        api: 'AsyncGeoboxClient', 
+        data: Optional[Dict] = {}):
         """
         [async] Initialize a workflow instance.
 
@@ -33,19 +33,18 @@ class Analysis(AsyncBase):
 
 
     def __repr__(self) -> str:
-        return f"Analysis()"
+        return f"AsyncRasterAnalysis()"
 
-    @classmethod
-    async def rasterize(cls, 
-        api: 'AsyncGeoboxClient',
-        layer: Union[VectorLayer, VectorLayerView],
+
+    async def rasterize(self, 
+        layer: Union[AsyncVectorLayer, AsyncVectorLayerView],
         output_raster_name: str,
         pixel_size: int = 10,
         nodata: Optional[int] = -9999,
         data_type: Optional[AnalysisDataType] = AnalysisDataType.int16,
         burn_value: Optional[int] = 1,
         burn_attribute: Optional[str] = None,
-        user_id: Optional[int] = None) -> 'Task':
+        user_id: Optional[int] = None) -> 'AsyncTask':
         """
         [async] Rasterize a vector layer
 
@@ -54,8 +53,7 @@ class Analysis(AsyncBase):
         Only users with Publisher role or higher can perform this operation.
 
         Args:
-            api (AsyncGeoboxClient): The AsyncGeoboxClient instance for making requests
-            layer (VectorLayer | VectorLayerView): VectorLayer or VectorLayerView instance
+            layer (AsyncVectorLayer | AsyncVectorLayerView): VectorLayer or VectorLayerView instance
             output_raster_name (str): Name for the output raster dataset
             pixel_size (int, optional): Pixel size for the output raster (must be > 0). default: 10
             nodata (int, optional): NoData value to use in the output raster. default: -9999
@@ -65,26 +63,27 @@ class Analysis(AsyncBase):
             user_id (int, optional): specific user. priviledges required!
 
         Returns:
-            Task: task instance of the process
+            AsyncTask: task instance of the process
 
         Example:
             >>> from geobox.aio import AsyncGeoboxClient
-            >>> from geobox.aio.raster_analysis import Analysis
+            >>> from geobox.aio.raster_analysis import AsyncRasterAnalysis
             >>> async with AsyncGeoboxClient() as client:
             >>>     vector = await client.get_vector(uuid="12345678-1234-5678-1234-567812345678")
-            >>>     task = await Analysis.rasterize(api=client, layer=vector, output_raster_name='test')
+            >>>     task = await client.raster_analysis.rasterize(layer=vector, output_raster_name='test')
             or  
-            >>>     task = await vector.rasterize(output_raster_name='test')
+            >>>     raster_analysis = AsyncRasterAnalysis(client)
+            >>>     task = await raster_analysis.rasterize(layer=vector, output_raster_name='test')
         """
-        if not isinstance(layer, VectorLayer) and not isinstance(layer, VectorLayerView):
+        if not isinstance(layer, AsyncVectorLayer) and not isinstance(layer, AsyncVectorLayerView):
             raise ValueError("'layer' input only accepts vector layer and view objects!")
 
-        endpoint = f'{cls.BASE_ENDPOINT}rasterize/'
+        endpoint = f'{self.BASE_ENDPOINT}rasterize/'
 
         data = clean_data({
             'layer_uuid': layer.uuid,
             'output_raster_name': output_raster_name,
-            'is_view': False if isinstance(layer, VectorLayer) else True,
+            'is_view': False if isinstance(layer, AsyncVectorLayer) else True,
             'pixel_size': pixel_size,
             'nodata': nodata,
             'data_type': data_type.value,
@@ -93,14 +92,12 @@ class Analysis(AsyncBase):
             'user_id': user_id
         })
 
-        response = await api.post(endpoint=endpoint, payload=data, is_json=False)
-        return await api.get_task(response['task_id'])
+        response = await self.api.post(endpoint=endpoint, payload=data, is_json=False)
+        return await self.api.get_task(response['task_id'])
 
 
-    @classmethod
-    async def polygonize(cls,
-        api: 'AsyncGeoboxClient',
-        raster: 'Raster',
+    async def polygonize(self,
+        raster: 'AsyncRaster',
         output_layer_name: str,
         band_index: int = 1,
         value_field: Optional[str] = None,
@@ -108,14 +105,13 @@ class Analysis(AsyncBase):
         connectivity: PolygonizeConnectivity = PolygonizeConnectivity.connected_4,
         keep_values: Optional[str] = None,
         layer_name: Optional[str] = None,
-        user_id: Optional[int] = None) -> 'Task':
+        user_id: Optional[int] = None) -> 'AsyncTask':
         """
         [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 (AsyncGeoboxClient): The AsyncGeoboxClient 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
@@ -127,18 +123,19 @@ class Analysis(AsyncBase):
             user_id (int, optional): specific user. priviledges required!
 
         Returns:
-            Task: task instance of the process
+            AsyncTask: task instance of the process
 
         Example:
             >>> from geobox.aio import AsyncGeoboxClient
-            >>> from geobox.aio.raster_analysis import Analysis
+            >>> from geobox.aio.raster_analysis import AsyncRasterAnalysis
             >>> async with AsyncGeoboxClient() as client:
             >>>     raster = await client.get_raster(uuid="12345678-1234-5678-1234-567812345678")
-            >>>     task = await Analysis.polygonize(api=client, raster=raster, output_layer_name='test')
+            >>>     task = await client.raster_analysis.polygonize(raster=raster, output_layer_name='test')
             or  
-            >>>     task = await raster.polygonize(output_layer_name='test')
+            >>>     raster_analysis = AsyncRasterAnalysis(client)
+            >>>     task = await raster_analysis.polygonize(raster=raster, output_layer_name='test')
         """
-        endpoint = f'{cls.BASE_ENDPOINT}polygonize/'
+        endpoint = f'{self.BASE_ENDPOINT}polygonize/'
 
         data = clean_data({
             'raster_uuid': raster.uuid,
@@ -152,30 +149,27 @@ class Analysis(AsyncBase):
             'user_id': user_id
         })
 
-        response = await api.post(endpoint=endpoint, payload=data, is_json=False)
-        return await api.get_task(response['task_id'])
+        response = await self.api.post(endpoint=endpoint, payload=data, is_json=False)
+        return await self.api.get_task(response['task_id'])
 
 
-    @classmethod
-    async def clip(cls, 
-        api: 'AsyncGeoboxClient',
-        raster: 'Raster',
-        layer: Union[VectorLayer, VectorLayerView],
+    async def clip(self, 
+        raster: 'AsyncRaster',
+        layer: Union[AsyncVectorLayer, AsyncVectorLayerView],
         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':
+        user_id: Optional[int] = None) -> 'AsyncTask':
         """
         [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 (AsyncGeoboxClient): The AsyncGeoboxClient instance for making requests
             raster (Raster): Raster instance
-            layer (VectorLayer | VectorLayerView): VectorLayer or VectorLayerView instance
+            layer (AsyncVectorLayer | AsyncVectorLayerView): 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
@@ -184,28 +178,29 @@ class Analysis(AsyncBase):
             user_id (int, optional): specific user. priviledges required!
 
         Returns:
-            Task: task instance of the process
+            AsyncTask: task instance of the process
 
         Example:
             >>> from geobox.aio import AsyncGeoboxClient
-            >>> from geobox.aio.raster_analysis import Analysis
+            >>> from geobox.aio.raster_analysis import AsyncRasterAnalysis
             >>> 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")
-            >>>     task = await Analysis.clip(api=client, raster=raster, layer=vector, output_raster_name='test')
+            >>>     task = await client.raster_analysis.clip(raster=raster, layer=vector, output_raster_name='test')
             or  
-            >>>     task = await raster.clip(layer=vector, output_raster_name='test')
+            >>>     raster_analysis = AsyncRasterAnalysis(client)
+            >>>     task = await raster_analysis.clip(raster=raster, layer=vector, output_raster_name='test')
         """
-        if not isinstance(layer, VectorLayer) and not isinstance(layer, VectorLayerView):
+        if not isinstance(layer, AsyncVectorLayer) and not isinstance(layer, AsyncVectorLayerView):
             raise ValueError("'layer' input only accepts vector layer and view objects!")
 
-        endpoint = f'{cls.BASE_ENDPOINT}clip/'
+        endpoint = f'{self.BASE_ENDPOINT}clip/'
 
         data = clean_data({
             'raster_uuid': raster.uuid,
             'layer_uuid': layer.uuid,
             'output_raster_name': output_raster_name,
-            'is_view': False if isinstance(layer, VectorLayer) else True,
+            'is_view': False if isinstance(layer, AsyncVectorLayer) else True,
             'where': where,
             'dst_nodata': dst_nodata,
             'crop': crop,
@@ -213,13 +208,11 @@ class Analysis(AsyncBase):
             'user_id': user_id
         })
 
-        response = await api.post(endpoint=endpoint, payload=data, is_json=False)
-        return await api.get_task(response['task_id'])
+        response = await self.api.post(endpoint=endpoint, payload=data, is_json=False)
+        return await self.api.get_task(response['task_id'])
 
 
-    @classmethod
-    async def calculator(cls,
-        api: 'AsyncGeoboxClient',
+    async def calculator(self,
         variables: str,
         expr: str,
         output_raster_name: str,
@@ -227,7 +220,7 @@ class Analysis(AsyncBase):
         resample: AnalysisResampleMethod = AnalysisResampleMethod.bilinear,
         out_dtype: AnalysisDataType = AnalysisDataType.float32,
         dst_nodata: int = -9999,
-        user_id: Optional[int] = None) -> 'Task':
+        user_id: Optional[int] = None) -> 'AsyncTask':
         """
         [async] Perform raster calculator operations on multiple raster datasets.
 
@@ -240,7 +233,6 @@ class Analysis(AsyncBase):
             Multi-band operations: variables='{"IMG": ["raster_uuid_1", 2]}', expr="IMG*2"
 
         Args:
-            api (AsyncGeoboxClient): The AsyncGeoboxClient instance for making requests
             variables (str): JSON string mapping variable names to raster specifications. Format: '{"NIR": "raster_uuid_1", "RED": "raster_uuid_2"}' or '{"IMG": ["raster_uuid_1", 2]}' for multi-band operations.
             expr (str): Mathematical expression using NumPy syntax. Use variable names from the variables dict, e.g., '(NIR-RED)/(NIR+RED)' or 'where(SLOPE>30,1,0)' or 'where((dist_to_highway < 1000) & (slope < 10), 1, 0)' .Supported functions: np, sin, cos, tan, asin, acos, atan, sinh, cosh, tanh, exp, log, log10, sqrt, abs, floor, ceil, round, minimum, maximum, clip, where, isnan, isfinite, pi, e.
             output_raster_name (str): Name for the output raster dataset.
@@ -251,18 +243,23 @@ class Analysis(AsyncBase):
             user_id (int, optional): specific user. priviledges required!
 
         Returns:
-            Task: task instance of the process
+            AsyncTask: task instance of the process
 
         Example:
             >>> from geobox.aio import AsyncGeoboxClient
-            >>> from geobox.aio.raster_analysis import Analysis
+            >>> from geobox.aio.raster_analysis import AsyncRasterAnalysis
             >>> async with AsyncGeoboxClient() as client:
             >>>     raster = await client.get_raster(uuid="12345678-1234-5678-1234-567812345678")
-            >>>     task = await Analysis.calculator(api=client, variables={"NIR": "raster_uuid_1", "RED": "raster_uuid_2"},
+            >>>     task = await client.raster_analysis.calculator(variables={"NIR": "raster_uuid_1", "RED": "raster_uuid_2"},
+            ...         expr='where(SLOPE>30,1,0)',
+            ...         output_raster_name='test')
+            or
+            >>>     raster_analysis = AsyncRasterAnalysis(client)
+            >>>     task = raster_analysis.calculator(variables={"NIR": "raster_uuid_1", "RED": "raster_uuid_2"},
             ...         expr='where(SLOPE>30,1,0)',
             ...         output_raster_name='test')
         """
-        endpoint = f'{cls.BASE_ENDPOINT}calculator/'
+        endpoint = f'{self.BASE_ENDPOINT}calculator/'
 
         data = clean_data({
             'variables': variables,
@@ -275,28 +272,25 @@ class Analysis(AsyncBase):
             'user_id': user_id
         })
 
-        response = await api.post(endpoint=endpoint, payload=data, is_json=False)
-        return await api.get_task(response['task_id'])
+        response = await self.api.post(endpoint=endpoint, payload=data, is_json=False)
+        return await self.api.get_task(response['task_id'])
 
 
-    @classmethod
-    async def slope(cls,
-        api: 'AsyncGeoboxClient',
-        raster: 'Raster',
+    async def slope(self,
+        raster: 'AsyncRaster',
         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':
+        user_id: Optional[int] = None) -> 'AsyncTask':
         """
         [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:
-            api (AsyncGeoboxClient): The AsyncGeoboxClient instance for making requests
             raster (Raster): DEM Raster instance
             output_raster_name (str): Name for the output raster dataset.
             slope_units (SlopeUnit, optional): Slope units: 'degree' or 'percent'. default: SlopeUnit.degree
@@ -307,18 +301,19 @@ class Analysis(AsyncBase):
             user_id (int, optional): specific user. priviledges required!
 
         Returns:
-            Task: task instance of the process
+            AsyncTask: task instance of the process
 
         Example:
             >>> from geobox.aio import AsyncGeoboxClient
-            >>> from geobox.aio.raster_analysis import Analysis
+            >>> from geobox.aio.raster_analysis import AsyncRasterAnalysis
             >>> async with AsyncGeoboxClient() as client:
             >>>     raster = await client.get_raster(uuid="12345678-1234-5678-1234-567812345678")
-            >>>     task = await Analysis.slope(api=client, raster=raster, output_raster_name='test')
+            >>>     task = await client.raster_analysis.slope(raster=raster, output_raster_name='test')
             or  
-            >>>     task = await raster.slope(output_raster_name='test')
+            >>>     raster_analysis = AsyncRasterAnalysis(client)
+            >>>     task = await raster_analysis.slope(raster=raster, output_raster_name='test')
         """
-        endpoint = f'{cls.BASE_ENDPOINT}slope/' 
+        endpoint = f'{self.BASE_ENDPOINT}slope/' 
 
         data = clean_data({
             'raster_uuid': raster.uuid,
@@ -331,21 +326,19 @@ class Analysis(AsyncBase):
             'user_id': user_id
         })
 
-        response = await api.post(endpoint=endpoint, payload=data, is_json=False)
-        return await api.get_task(response['task_id'])
+        response = await self.api.post(endpoint=endpoint, payload=data, is_json=False)
+        return await self.api.get_task(response['task_id'])
 
 
-    @classmethod
-    async def aspect(cls,
-        api: 'AsyncGeoboxClient',
-        raster: 'Raster',
+    async def aspect(self,
+        raster: 'AsyncRaster',
         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':
+        user_id: Optional[int] = None) -> 'AsyncTask':
         """
         [async] Calculate aspect from a DEM raster.
 
@@ -353,7 +346,6 @@ class Analysis(AsyncBase):
         Only users with Publisher role or higher can perform this operation.
 
         Args:
-            api (AsyncGeoboxClient): The AsyncGeoboxClient 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
@@ -364,19 +356,20 @@ class Analysis(AsyncBase):
             user_id (int, optional): specific user. priviledges required!
 
         Returns:
-            Task: task instance of the process
+            AsyncTask: task instance of the process
 
         Example:
             >>> from geobox.aio import AsyncGeoboxClient
-            >>> from geobox.aio.raster_analysis import Analysis
+            >>> from geobox.aio.raster_analysis import AsyncRasterAnalysis
             >>> async with AsyncGeoboxClient() as client:
             >>>     raster = await client.get_raster(uuid="12345678-1234-5678-1234-567812345678")
-            >>>     task = await Analysis.aspect(api=client, raster=raster, output_raster_name='test')
+            >>>     task = await client.raster_analysis.aspect(raster=raster, output_raster_name='test')
             or  
-            >>>     task = await raster.aspect(output_raster_name='test')
+            >>>     raster_analysis = AsyncRasterAnalysis(client)
+            >>>     task = await raster_analysis.aspect(raster=raster, output_raster_name='test')
         """
 
-        endpoint = f'{cls.BASE_ENDPOINT}aspect/' 
+        endpoint = f'{self.BASE_ENDPOINT}aspect/' 
 
         data = clean_data({
             'raster_uuid': raster.uuid,
@@ -389,14 +382,12 @@ class Analysis(AsyncBase):
             'user_id': user_id
         })
 
-        response = await api.post(endpoint=endpoint, payload=data, is_json=False)
-        return await api.get_task(response['task_id'])
+        response = await self.api.post(endpoint=endpoint, payload=data, is_json=False)
+        return await self.api.get_task(response['task_id'])
 
 
-    @classmethod
-    async def reclassify(cls,
-        api: 'AsyncGeoboxClient',
-        raster: 'Raster',
+    async def reclassify(self,
+        raster: 'AsyncRaster',
         output_raster_name: str,
         rules: str,
         default_value: Optional[int] = None,
@@ -404,7 +395,7 @@ class Analysis(AsyncBase):
         nodata_out: int = -9999,
         out_dtype: AnalysisDataType = AnalysisDataType.int16,
         inclusive: RangeBound = RangeBound.left,
-        user_id: Optional[int] = None) -> 'Task':
+        user_id: Optional[int] = None) -> 'AsyncTask':
         """
         [async] Reclassify a raster using value mapping or class breaks.
 
@@ -412,7 +403,6 @@ class Analysis(AsyncBase):
         Only users with Publisher role or higher can perform this operation.
 
         Args:
-            api (AsyncGeoboxClient): The AsyncGeoboxClient instance for making requests
             raster (Raster): Raster instance
             output_raster_name (str): Name for the output reclassified raster dataset.
             rules (str): JSON string containing reclassification rules. 
@@ -429,18 +419,19 @@ class Analysis(AsyncBase):
             user_id (int, optional): specific user. priviledges required!
 
         Returns:
-            Task: task instance of the process
+            AsyncTask: task instance of the process
 
         Example:
             >>> from geobox.aio import AsyncGeoboxClient
-            >>> from geobox.aio.raster_analysis import Analysis
+            >>> from geobox.aio.raster_analysis import AsyncRasterAnalysis
             >>> async with AsyncGeoboxClient() as client:
             >>>     raster = await client.get_raster(uuid="12345678-1234-5678-1234-567812345678")
-            >>>     task = await Analysis.reclassify(api=client, raster=raster, output_raster_name='test', rules='{"1": 10, "2": 20, "3": 30}')
+            >>>     task = await client.raster_analysis.reclassify(raster=raster, output_raster_name='test', rules='{"1": 10, "2": 20, "3": 30}')
             or  
-            >>>     task = raster.reclassify(output_raster_name='test', rules='{"1": 10, "2": 20, "3": 30}')
+            >>>     raster_analysis = AsyncRasterAnalysis(client)
+            >>>     task = raster_analysis.reclassify(raster=raster, output_raster_name='test', rules='{"1": 10, "2": 20, "3": 30}')
         """
-        endpoint = f'{cls.BASE_ENDPOINT}reclassify/'
+        endpoint = f'{self.BASE_ENDPOINT}reclassify/'
 
         data = clean_data({
             'raster_uuid': raster.uuid,
@@ -455,21 +446,19 @@ class Analysis(AsyncBase):
             'user_id': user_id
         })
 
-        response = await api.post(endpoint=endpoint, payload=data, is_json=False)
-        return await api.get_task(response['task_id'])
+        response = await self.api.post(endpoint=endpoint, payload=data, is_json=False)
+        return await self.api.get_task(response['task_id'])
 
 
-    @classmethod
-    async def resample(cls,
-        api: 'AsyncGeoboxClient',
-        raster: 'Raster',
+    async def resample(self,
+        raster: 'AsyncRaster',
         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':
+        user_id: Optional[int] = None) -> 'AsyncTask':
         """
         [async] Resample a raster to a different resolution.
 
@@ -478,7 +467,6 @@ class Analysis(AsyncBase):
         Only users with Publisher role or higher can perform this operation.
 
         Args:
-            api (AsyncGeoboxClient): The AsyncGeoboxClient instance for making requests
             raster (Raster): Raster instance
             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').
@@ -489,21 +477,22 @@ class Analysis(AsyncBase):
             user_id (int, optional): specific user. priviledges required!
 
         Returns:
-            Task: task instance of the process
+            AsyncTask: task instance of the process
 
         Example:
             >>> from geobox.aio import AsyncGeoboxClient
-            >>> from geobox.aio.raster_analysis import Analysis
+            >>> from geobox.aio.raster_analysis import AsyncRasterAnalysis
             >>> async with AsyncGeoboxClient() as client:
             >>>     raster = await client.get_raster(uuid="12345678-1234-5678-1234-567812345678")
-            >>>     task = await Analysis.resample(api=client, raster=raster, output_raster_name='test', out_res='10,10')
+            >>>     task = await client.raster_analysis.resample(raster=raster, output_raster_name='test', out_res='10,10')
             or  
-            >>>     task = await raster.resample(output_raster_name='test', out_res='10,10')
+            >>>     raster_analysis = AsyncRasterAnalysis(client)
+            >>>     task = await raster_analysis.resample(raster=raster, output_raster_name='test', out_res='10,10')
         """
         if sum(x is not None for x in [out_res, scale_factor, match_raster_uuid]) != 1:
             raise ValueError('Exactly one of out_res, scale_factor, or match_raster_uuid must be provided!')
 
-        endpoint = f'{cls.BASE_ENDPOINT}resample/'
+        endpoint = f'{self.BASE_ENDPOINT}resample/'
 
         data = clean_data({
             'raster_uuid': raster.uuid,
@@ -516,14 +505,12 @@ class Analysis(AsyncBase):
             'user_id': user_id
         })
 
-        response = await api.post(endpoint=endpoint, payload=data, is_json=False)
-        return await api.get_task(response['task_id'])
+        response = await self.api.post(endpoint=endpoint, payload=data, is_json=False)
+        return await self.api.get_task(response['task_id'])
 
 
-    @classmethod
-    async def idw_interpolation(cls,
-        api: 'AsyncGeoboxClient',
-        layer: Union[VectorLayer, VectorLayerView],
+    async def idw_interpolation(self,
+        layer: Union[AsyncVectorLayer, AsyncVectorLayerView],
         output_raster_name: str,
         z_field: Field,
         match_raster_uuid: Optional[str] = None,
@@ -535,7 +522,7 @@ class Analysis(AsyncBase):
         radius: int = 1000,
         nodata: int = -9999,
         out_dtype: AnalysisDataType = AnalysisDataType.float32,
-        user_id: Optional[int] = None) -> 'Task':
+        user_id: Optional[int] = None) -> 'AsyncTask':
         """
         [async] Create an IDW (Inverse Distance Weighting) interpolation raster from point data.
 
@@ -543,8 +530,7 @@ class Analysis(AsyncBase):
         Only users with Publisher role or higher can perform this operation.
 
         Args:
-            api (AsyncGeoboxClient): The AsyncGeoboxClient instance for making requests
-            layer (VectorLayer | VectorLayerview): layer containing point data 
+            layer (AsyncVectorLayer | AsyncVectorLayerview): layer containing point data 
             output_raster_name (str): Name for the output IDW raster dataset.
             z_field (Field): the field containing the values to interpolate.
             match_raster_uuid (str, optional): UUID of reference raster to match resolution/extent.
@@ -559,25 +545,26 @@ class Analysis(AsyncBase):
             user_id (int, optional): specific user. priviledges required!
 
         Returns:
-            Task: task instance of the process
+            AsyncTask: task instance of the process
 
         Example:
             >>> from geobox.aio import AsyncGeoboxClient
-            >>> from geobox.aio.raster_analysis import Analysis
+            >>> from geobox.aio.raster_analysis import AsyncRasterAnalysis
             >>> async with AsyncGeoboxClient() as client:
             >>>     vector = await client.get_vector(uuid="12345678-1234-5678-1234-567812345678")
             >>>     field = await vector.get_field_by_name('field_name')
-            >>>     task = await Analysis.idw(api=client, layer=vector, output_raster_name='test', z_field=field)
+            >>>     task = await client.raster_analysis.idw_interpolation(layer=vector, output_raster_name='test', z_field=field)
             or  
-            >>>     task = await vector.idw(output_raster_name='test', z_field=field)
+            >>>     raster_analysis = AsyncRasterAnalysis(client)
+            >>>     task = await raster_analysis.idw_interpolation(layer=vector, output_raster_name='test', z_field=field)
         """
-        endpoint = f'{cls.BASE_ENDPOINT}idw/'
+        endpoint = f'{self.BASE_ENDPOINT}idw/'
 
         data = clean_data({
             'layer_uuid': layer.uuid,
             'output_raster_name': output_raster_name,
             'z_field': z_field.name,
-            'is_view': False if isinstance(layer, VectorLayer) else True,
+            'is_view': False if isinstance(layer, AsyncVectorLayer) else True,
             'match_raster_uuid': match_raster_uuid,
             'pixel_size': pixel_size,
             'extent': extent,
@@ -590,13 +577,11 @@ class Analysis(AsyncBase):
             'user_id': user_id
         })
         
-        response = await api.post(endpoint=endpoint, payload=data, is_json=False)
-        return await api.get_task(response['task_id'])
+        response = await self.api.post(endpoint=endpoint, payload=data, is_json=False)
+        return await self.api.get_task(response['task_id'])
 
 
-    @classmethod
-    async def constant(cls,
-        api: 'AsyncGeoboxClient',
+    async def constant(self,
         output_raster_name: str,
         extent: str,
         value : int,
@@ -604,7 +589,7 @@ class Analysis(AsyncBase):
         dtype: AnalysisDataType = AnalysisDataType.float32,
         nodata: int = -9999,
         align_to: Optional[str] = None,
-        user_id: Optional[int] = None) -> 'Task':
+        user_id: Optional[int] = None) -> 'AsyncTask':
         """
         [async] Create a raster filled with a constant value.
 
@@ -612,7 +597,6 @@ class Analysis(AsyncBase):
         Only users with Publisher role or higher can perform this operation.
 
         Args:
-            api (AsyncGeoboxClient): The AsyncGeoboxClient instance for making requests
             output_raster_name (str): Name for the output constant raster dataset.
             extent (str): Extent as 'minX,minY,maxX,maxY' (e.g., '0,0,100,100').
             value (int): Constant value to fill the raster with.
@@ -623,15 +607,18 @@ class Analysis(AsyncBase):
             user_id (int, optional): specific user. priviledges required!
 
         Returns:
-            Task: task instance of the process
+            AsyncTask: task instance of the process
 
         Example:
             >>> from geobox.aio import AsyncGeoboxClient
-            >>> from geobox.aio.raster_analysis import Analysis
+            >>> from geobox.aio.raster_analysis import AsyncRasterAnalysis
             >>> async with AsyncGeoboxClient() as client:
-            >>>     task = await Analysis.constant(api=client, output_raster_name='test', extent='0,0,100,100', value=10)
+            >>>     task = await client.raster_analysis.constant(output_raster_name='test', extent='0,0,100,100', value=10)
+            or
+            >>>     raster_analysis = AsyncRasterAnalysis(client)
+            >>>     task = await raster_analysis.constant(output_raster_name='test', extent='0,0,100,100', value=10)
         """
-        endpoint = f'{cls.BASE_ENDPOINT}constant/'
+        endpoint = f'{self.BASE_ENDPOINT}constant/'
 
         data = clean_data({
             'output_raster_name': output_raster_name,
@@ -644,21 +631,19 @@ class Analysis(AsyncBase):
             'user_id': user_id
         })
 
-        response = await api.post(endpoint=endpoint, payload=data, is_json=False)
-        return await api.get_task(response['task_id'])
+        response = await self.api.post(endpoint=endpoint, payload=data, is_json=False)
+        return await self.api.get_task(response['task_id'])
 
 
-    @classmethod
-    async def fill_nodata(cls,
-        api: 'AsyncGeoboxClient',
-        raster: 'Raster',
+    async def fill_nodata(self,
+        raster: 'AsyncRaster',
         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':
+        user_id: Optional[int] = None) -> 'AsyncTask':
         """
         [async] Fill NoData regions in a raster using GDAL's FillNodata algorithm.
 
@@ -667,7 +652,6 @@ class Analysis(AsyncBase):
         Only users with Publisher role or higher can perform this operation.
 
         Args:
-            api (AsyncGeoboxClient): The AsyncGeoboxClient instance for making requests
             raster (Raster): the input raster to fill NoData regions in
             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
@@ -678,18 +662,19 @@ class Analysis(AsyncBase):
             user_id (int, optional): specific user. priviledges required!
 
         Returns:
-            Task: task instance of the process
+            AsyncTask: task instance of the process
 
         Example:
             >>> from geobox.aio import AsyncGeoboxClient
-            >>> from geobox.aio.raster_analysis import Analysis
+            >>> from geobox.aio.raster_analysis import AsyncRasterAnalysis
             >>> async with AsyncGeoboxClient() as client:
             >>>     raster = await client.get_raster(uuid="12345678-1234-5678-1234-567812345678")
-            >>>     task = await Analysis.fill_nodata(api=client, raster=raster, output_raster_name='test')
+            >>>     task = await client.raster_analysis.fill_nodata(raster=raster, output_raster_name='test')
             or  
-            >>>     task = await raster.fill_nodata(output_raster_name='test')
+            >>>     raster_analysis = AsyncRasterAnalysis(client)
+            >>>     task = await raster_analyis.fill_nodata(raster=raster, output_raster_name='test')
         """
-        endpoint = f'{cls.BASE_ENDPOINT}fill/'
+        endpoint = f'{self.BASE_ENDPOINT}fill/'
 
         data = clean_data({
             'raster_uuid': raster.uuid,
@@ -702,19 +687,17 @@ class Analysis(AsyncBase):
             'user_id': user_id
         })
 
-        response = await api.post(endpoint=endpoint, payload=data, is_json=False)
-        return await api.get_task(response['task_id'])
+        response = await self.api.post(endpoint=endpoint, payload=data, is_json=False)
+        return await self.api.get_task(response['task_id'])
 
 
-    @classmethod
-    async def proximity(cls,
-        api: 'AsyncGeoboxClient',
-        raster: 'Raster',
+    async def proximity(self,
+        raster: 'AsyncRaster',
         output_raster_name: str,
         dist_units: DistanceUnit = DistanceUnit.GEO,
         burn_value: int = 1,
         nodata: int = -9999,
-        user_id: Optional[int] = None) -> 'Task':
+        user_id: Optional[int] = None) -> 'AsyncTask':
         """
         [async] Create a proximity (distance) raster from a raster layer.
 
@@ -722,7 +705,6 @@ class Analysis(AsyncBase):
         Only users with Publisher role or higher can perform this operation.
 
         Args:
-            api (AsyncGeoboxClient): The AsyncGeoboxClient instance for making requests
             raster (Raster): the raster layer to create proximity raster from.
             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
@@ -731,18 +713,19 @@ class Analysis(AsyncBase):
             user_id (int, optional): specific user. priviledges required!
 
         Returns:
-            Task: task instance of the process
+            AsyncTask: task instance of the process
 
         Example:
             >>> from geobox.aio import AsyncGeoboxClient
-            >>> from geobox.aio.raster_analysis import Analysis
+            >>> from geobox.aio.raster_analysis import AsyncRasterAnalysis
             >>> async with AsyncGeoboxClient() as client:
             >>>     raster = await client.get_raster(uuid="12345678-1234-5678-1234-567812345678")
-            >>>     task = await Analysis.proximity(api=client, raster=raster, output_raster_name='test')
+            >>>     task = await client.raster_analysis.proximity(raster=raster, output_raster_name='test')
             or  
-            >>>     task = await raster.proximity(output_raster_name='test')
+            >>>     raster_analysis = AsyncRasterAnalysis(client)
+            >>>     task = await raster_analysis.proximity(raster=raster, output_raster_name='test')
         """
-        endpoint = f'{cls.BASE_ENDPOINT}proximity/'
+        endpoint = f'{self.BASE_ENDPOINT}proximity/'
 
         data = clean_data({
             'raster_uuid': raster.uuid,
@@ -753,5 +736,5 @@ class Analysis(AsyncBase):
             'user_id': user_id
         })
 
-        response = await api.post(endpoint=endpoint, payload=data, is_json=False)
-        return await api.get_task(response['task_id'])
+        response = await self.api.post(endpoint=endpoint, payload=data, is_json=False)
+        return await self.api.get_task(response['task_id'])