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

geobox/{analysis.py → raster_analysis.py}

@@ -14,30 +14,25 @@ if TYPE_CHECKING:
     from . import GeoboxClient
     from .task import Task
 
-class Analysis(Base):
+class RasterAnalysis(Base):
 
     BASE_ENDPOINT = 'analysis/'
 
-    def __init__(self, 
-                 api: 'GeoboxClient', 
-                 data: Optional[Dict] = {}):
+    def __init__(self, api: 'GeoboxClient'):
         """
-        Initialize a workflow instance.
+        Initialize a RasterAnalysis instance.
 
         Args:
             api (GeoboxClient): The GeoboxClient instance for making requests.
-            uuid (str): The unique identifier for the workflow.
-            data (Dict): The response data of the workflow.
         """
-        super().__init__(api, data=data)
+        super().__init__(api)
 
 
     def __repr__(self) -> str:
-        return f"Analysis()"
+        return f"RasterAnalysis()"
 
-    @classmethod
-    def rasterize(cls, 
-        api: 'GeoboxClient',
+
+    def rasterize(self, 
         layer: Union[VectorLayer, VectorLayerView],
         output_raster_name: str,
         pixel_size: int = 10,
@@ -54,7 +49,6 @@ class Analysis(Base):
         Only users with Publisher role or higher can perform this operation.
 
         Args:
-            api (GeoboxClient): The GeoboxClient instance for making requests
             layer (VectorLayer | VectorLayerView): 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
@@ -69,17 +63,18 @@ class Analysis(Base):
 
         Example:
             >>> from geobox import GeoboxClient
-            >>> from geobox.raster_analysis import Analysis
+            >>> from geobox.raster_analysis import RasterAnalysis
             >>> client = GeoboxClient()
             >>> vector = client.get_vector(uuid="12345678-1234-5678-1234-567812345678")
-            >>> task = Analysis.rasterize(api=client, layer=vector, output_raster_name='test')
+            >>> task = client.raster_analysis.rasterize(layer=vector, output_raster_name='test')
             or
-            >>> task = vector.rasterize(output_raster_name='test')
+            >>> raster_analysis = RasterAnalysis(client)
+            >>> task = raster_analysis.rasterize(layer=vector, output_raster_name='test')
         """
         if not isinstance(layer, VectorLayer) and not isinstance(layer, VectorLayerView):
             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,
@@ -93,13 +88,11 @@ class Analysis(Base):
             'user_id': user_id
         })
 
-        response = api.post(endpoint=endpoint, payload=data, is_json=False)
-        return api.get_task(response['task_id'])
+        response = self.api.post(endpoint=endpoint, payload=data, is_json=False)
+        return self.api.get_task(response['task_id'])
 
 
-    @classmethod
-    def polygonize(cls,
-        api: 'GeoboxClient',
+    def polygonize(self,
         raster: 'Raster',
         output_layer_name: str,
         band_index: int = 1,
@@ -115,7 +108,6 @@ class Analysis(Base):
         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
@@ -131,14 +123,15 @@ class Analysis(Base):
 
         Example:
             >>> from geobox import GeoboxClient
-            >>> from geobox.raster_analysis import Analysis
+            >>> from geobox.raster_analysis import RasterAnalysis
             >>> client = GeoboxClient()
             >>> raster = client.get_raster(uuid="12345678-1234-5678-1234-567812345678")
-            >>> task = Analysis.polygonize(api=client, raster=raster, output_layer_name='test')
+            >>> task = client.raster_analysis.polygonize(raster=raster, output_layer_name='test')
             or
-            >>> task = raster.polygonize(output_layer_name='test')
+            >>> raster_analysis = RasterAnalysis(client)
+            >>> task = 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,13 +145,11 @@ class Analysis(Base):
             'user_id': user_id
         })
 
-        response = api.post(endpoint=endpoint, payload=data, is_json=False)
-        return api.get_task(response['task_id'])
+        response = self.api.post(endpoint=endpoint, payload=data, is_json=False)
+        return self.api.get_task(response['task_id'])
 
 
-    @classmethod
-    def clip(cls, 
-        api: 'GeoboxClient',
+    def clip(self, 
         raster: 'Raster',
         layer: Union[VectorLayer, VectorLayerView],
         output_raster_name: str,
@@ -173,7 +164,6 @@ class Analysis(Base):
         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
@@ -188,18 +178,19 @@ class Analysis(Base):
 
         Example:
             >>> from geobox import GeoboxClient
-            >>> from geobox.raster_analysis import Analysis
+            >>> from geobox.raster_analysis import RasterAnalysis
             >>> client = GeoboxClient()
             >>> raster = client.get_raster(uuid="12345678-1234-5678-1234-567812345678")
             >>> vector = client.get_vector(uuid="12345678-1234-5678-1234-567812345678")
-            >>> task = Analysis.clip(api=client, raster=raster, layer=vector, output_raster_name='test')
+            >>> task = client.raster_analysis.clip(layer=vector, output_raster_name='test')
             or
-            >>> task = raster.clip(layer=vector, output_raster_name='test')
+            >>> raster_analysis = RasterAnalysis(client)
+            >>> task = raster_analysis.clip(raster=raster, layer=vector, output_raster_name='test')
         """
         if not isinstance(layer, VectorLayer) and not isinstance(layer, VectorLayerView):
             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,
@@ -213,13 +204,11 @@ class Analysis(Base):
             'user_id': user_id
         })
 
-        response = api.post(endpoint=endpoint, payload=data, is_json=False)
-        return api.get_task(response['task_id'])
+        response = self.api.post(endpoint=endpoint, payload=data, is_json=False)
+        return self.api.get_task(response['task_id'])
 
 
-    @classmethod
-    def calculator(cls,
-        api: 'GeoboxClient',
+    def calculator(self,
         variables: str,
         expr: str,
         output_raster_name: str,
@@ -240,7 +229,6 @@ class Analysis(Base):
             Multi-band operations: variables='{"IMG": ["raster_uuid_1", 2]}', expr="IMG*2"
 
         Args:
-            api (GeoboxClient): The GeoboxClient 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.
@@ -255,14 +243,19 @@ class Analysis(Base):
 
         Example:
             >>> from geobox import GeoboxClient
-            >>> from geobox.raster_analysis import Analysis
+            >>> from geobox.raster_analysis import RasterAnalysis
             >>> client = GeoboxClient()
             >>> raster = client.get_raster(uuid="12345678-1234-5678-1234-567812345678")
-            >>> task = Analysis.calculator(api=client, variables={"NIR": "raster_uuid_1", "RED": "raster_uuid_2"},
+            >>> task = 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 = RasterAnalysis(client)
+            >>> task = raster_analysis.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,13 +268,11 @@ class Analysis(Base):
             'user_id': user_id
         })
 
-        response = api.post(endpoint=endpoint, payload=data, is_json=False)
-        return api.get_task(response['task_id'])
+        response = self.api.post(endpoint=endpoint, payload=data, is_json=False)
+        return self.api.get_task(response['task_id'])
 
 
-    @classmethod
-    def slope(cls,
-        api: 'GeoboxClient',
+    def slope(self,
         raster: 'Raster',
         output_raster_name: str,
         slope_units: SlopeUnit = SlopeUnit.degree,
@@ -296,7 +287,6 @@ class Analysis(Base):
         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 (GeoboxClient): The GeoboxClient 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
@@ -311,14 +301,15 @@ class Analysis(Base):
 
         Example:
             >>> from geobox import GeoboxClient
-            >>> from geobox.raster_analysis import Analysis
+            >>> from geobox.raster_analysis import RasterAnalysis
             >>> client = GeoboxClient()
             >>> raster = client.get_raster(uuid="12345678-1234-5678-1234-567812345678")
-            >>> task = Analysis.slope(api=client, raster=raster, output_raster_name='test')
+            >>> task = client.raster_analysis.slope(raster=raster, output_raster_name='test')
             or
-            >>> task = raster.slope(output_raster_name='test')
+            >>> raster_analysis = RasterAnalysis(client)
+            >>> task = 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,13 +322,11 @@ class Analysis(Base):
             'user_id': user_id
         })
 
-        response = api.post(endpoint=endpoint, payload=data, is_json=False)
-        return api.get_task(response['task_id'])
+        response = self.api.post(endpoint=endpoint, payload=data, is_json=False)
+        return self.api.get_task(response['task_id'])
 
 
-    @classmethod
-    def aspect(cls,
-        api: 'GeoboxClient',
+    def aspect(self,
         raster: 'Raster',
         output_raster_name: str,
         algorithm: AnalysisAlgorithm = AnalysisAlgorithm.Horn,
@@ -353,7 +342,6 @@ class Analysis(Base):
         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
@@ -368,15 +356,17 @@ class Analysis(Base):
 
         Example:
             >>> from geobox import GeoboxClient
-            >>> from geobox.raster_analysis import Analysis
+            >>> from geobox.raster_analysis import RasterAnalysis
+
             >>> client = GeoboxClient()
             >>> raster = client.get_raster(uuid="12345678-1234-5678-1234-567812345678")
-            >>> task = Analysis.aspect(api=client, raster=raster, output_raster_name='test')
+            >>> task = cient.raster_analysis.aspect(raster=raster, output_raster_name='test')
             or
-            >>> task = raster.aspect(output_raster_name='test')
+            >>> raster_analysis = RasterAnalysis(client)
+            >>> task = 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,13 +379,11 @@ class Analysis(Base):
             'user_id': user_id
         })
 
-        response = api.post(endpoint=endpoint, payload=data, is_json=False)
-        return api.get_task(response['task_id'])
+        response = self.api.post(endpoint=endpoint, payload=data, is_json=False)
+        return self.api.get_task(response['task_id'])
 
 
-    @classmethod
-    def reclassify(cls,
-        api: 'GeoboxClient',
+    def reclassify(self,
         raster: 'Raster',
         output_raster_name: str,
         rules: str,
@@ -412,7 +400,6 @@ class Analysis(Base):
         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_raster_name (str): Name for the output reclassified raster dataset.
             rules (str): JSON string containing reclassification rules. 
@@ -433,14 +420,15 @@ class Analysis(Base):
 
         Example:
             >>> from geobox import GeoboxClient
-            >>> from geobox.raster_analysis import Analysis
+            >>> from geobox.raster_analysis import RasterAnalysis
             >>> client = GeoboxClient()
             >>> raster = client.get_raster(uuid="12345678-1234-5678-1234-567812345678")
-            >>> task = Analysis.reclassify(api=client, raster=raster, output_raster_name='test', rules='{"1": 10, "2": 20, "3": 30}')
+            >>> task = 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 = RasterAnalysis(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,13 +443,11 @@ class Analysis(Base):
             'user_id': user_id
         })
 
-        response = api.post(endpoint=endpoint, payload=data, is_json=False)
-        return api.get_task(response['task_id'])
+        response = self.api.post(endpoint=endpoint, payload=data, is_json=False)
+        return self.api.get_task(response['task_id'])
 
 
-    @classmethod
-    def resample(cls,
-        api: 'GeoboxClient',
+    def resample(self,
         raster: 'Raster',
         output_raster_name: str,
         out_res: Optional[str] = None,
@@ -478,7 +464,6 @@ class Analysis(Base):
         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_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').
@@ -493,17 +478,18 @@ class Analysis(Base):
 
         Example:
             >>> from geobox import GeoboxClient
-            >>> from geobox.raster_analysis import Analysis
+            >>> from geobox.raster_analysis import RasterAnalysis
             >>> client = GeoboxClient()
             >>> raster = client.get_raster(uuid="12345678-1234-5678-1234-567812345678")
-            >>> task = Analysis.resample(api=client, raster=raster, output_raster_name='test', out_res='10,10')
+            >>> task = client.raster_analysis.resample(raster=raster, output_raster_name='test', out_res='10,10')
             or
-            >>> task = raster.resample(output_raster_name='test', out_res='10,10')
+            >>> raster_analysis = RasterAnalysis(client)
+            >>> task = 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,13 +502,11 @@ class Analysis(Base):
             'user_id': user_id
         })
 
-        response = api.post(endpoint=endpoint, payload=data, is_json=False)
-        return api.get_task(response['task_id'])
+        response = self.api.post(endpoint=endpoint, payload=data, is_json=False)
+        return self.api.get_task(response['task_id'])
 
 
-    @classmethod
-    def idw_interpolation(cls,
-        api: 'GeoboxClient',
+    def idw_interpolation(self,
         layer: Union[VectorLayer, VectorLayerView],
         output_raster_name: str,
         z_field: Field,
@@ -543,7 +527,6 @@ class Analysis(Base):
         Only users with Publisher role or higher can perform this operation.
 
         Args:
-            api (GeoboxClient): The GeoboxClient instance for making requests
             layer (VectorLayer | VectorLayerview): 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.
@@ -563,15 +546,16 @@ class Analysis(Base):
 
         Example:
             >>> from geobox import GeoboxClient
-            >>> from geobox.raster_analysis import Analysis
+            >>> from geobox.raster_analysis import RasterAnalysis
             >>> client = GeoboxClient()
             >>> vector = client.get_vector(uuid="12345678-1234-5678-1234-567812345678")
             >>> field = vector.get_field_by_name('field_name')
-            >>> task = Analysis.idw(api=client, layer=vector, output_raster_name='test', z_field=field)
+            >>> task = client.raster_analysis.idw_interpolation(layer=vector, output_raster_name='test', z_field=field)
             or
-            >>> task = vector.idw(output_raster_name='test', z_field=field)
+            >>> raster_analysis = RasterAnalysis(client)
+            >>> task = 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,
@@ -590,13 +574,11 @@ class Analysis(Base):
             'user_id': user_id
         })
         
-        response = api.post(endpoint=endpoint, payload=data, is_json=False)
-        return api.get_task(response['task_id'])
+        response = self.api.post(endpoint=endpoint, payload=data, is_json=False)
+        return self.api.get_task(response['task_id'])
 
 
-    @classmethod
-    def constant(cls,
-        api: 'GeoboxClient',
+    def constant(self,
         output_raster_name: str,
         extent: str,
         value : int,
@@ -608,11 +590,10 @@ class Analysis(Base):
         """
         Create a raster filled with a constant value.
 
-        This endpoint creates a north-up GeoTIFF filled with a constant value. 
+        It creates a north-up GeoTIFF filled with a constant value. 
         Only users with Publisher role or higher can perform this operation.
 
         Args:
-            api (GeoboxClient): The GeoboxClient 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.
@@ -627,11 +608,14 @@ class Analysis(Base):
 
         Example:
             >>> from geobox import GeoboxClient
-            >>> from geobox.raster_analysis import Analysis
+            >>> from geobox.raster_analysis import RasterAnalysis
             >>> client = GeoboxClient()
-            >>> task = Analysis.constant(api=client, output_raster_name='test', extent='0,0,100,100', value=10)
+            >>> task = client.raster_analysis.constant(output_raster_name='test', extent='0,0,100,100', value=10)
+            or
+            >>> raster_analysis = RasterAnalysis(client)
+            >>> task = 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,13 +628,11 @@ class Analysis(Base):
             'user_id': user_id
         })
 
-        response = api.post(endpoint=endpoint, payload=data, is_json=False)
-        return api.get_task(response['task_id'])
+        response = self.api.post(endpoint=endpoint, payload=data, is_json=False)
+        return self.api.get_task(response['task_id'])
 
 
-    @classmethod
-    def fill_nodata(cls,
-        api: 'GeoboxClient',
+    def fill_nodata(self,
         raster: 'Raster',
         output_raster_name: str,
         band: Union[int, str] = 1,
@@ -667,7 +649,6 @@ class Analysis(Base):
         Only users with Publisher role or higher can perform this operation.
 
         Args:
-            api (GeoboxClient): The GeoboxClient 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
@@ -682,14 +663,15 @@ class Analysis(Base):
 
         Example:
             >>> from geobox import GeoboxClient
-            >>> from geobox.raster_analysis import Analysis
+            >>> from geobox.raster_analysis import RasterAnalysis
             >>> client = GeoboxClient()
             >>> raster = client.get_raster(uuid="12345678-1234-5678-1234-567812345678")
-            >>> task = Analysis.fill_nodata(api=client, raster=raster, output_raster_name='test')
+            >>> task = client.raster_analysis.fill_nodata(raster=raster, output_raster_name='test')
             or
-            >>> task = raster.fill_nodata(output_raster_name='test')
+            >>> raster_analysis = RasterAnalysis(client)
+            >>> task = raster_analysis.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,13 +684,11 @@ class Analysis(Base):
             'user_id': user_id
         })
 
-        response = api.post(endpoint=endpoint, payload=data, is_json=False)
-        return api.get_task(response['task_id'])
+        response = self.api.post(endpoint=endpoint, payload=data, is_json=False)
+        return self.api.get_task(response['task_id'])
 
 
-    @classmethod
-    def proximity(cls,
-        api: 'GeoboxClient',
+    def proximity(self,
         raster: 'Raster',
         output_raster_name: str,
         dist_units: DistanceUnit = DistanceUnit.GEO,
@@ -722,7 +702,6 @@ class Analysis(Base):
         Only users with Publisher role or higher can perform this operation.
 
         Args:
-            api (GeoboxClient): The GeoboxClient 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
@@ -735,14 +714,15 @@ class Analysis(Base):
 
         Example:
             >>> from geobox import GeoboxClient
-            >>> from geobox.raster_analysis import Analysis
+            >>> from geobox.raster_analysis import RasterAnalysis
             >>> client = GeoboxClient()
             >>> raster = client.get_raster(uuid="12345678-1234-5678-1234-567812345678")
-            >>> task = Analysis.proximity(api=client, raster=raster, output_raster_name='test')
+            >>> task = client.raster_analysis.proximity(raster=raster, output_raster_name='test')
             or
-            >>> task = raster.proximity(output_raster_name='test')
+            >>> raster_analysis = RasterAnalysis(client)
+            >>> task = RasterAnalysis.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 +733,5 @@ class Analysis(Base):
             'user_id': user_id
         })
 
-        response = api.post(endpoint=endpoint, payload=data, is_json=False)
-        return api.get_task(response['task_id'])
+        response = self.api.post(endpoint=endpoint, payload=data, is_json=False)
+        return self.api.get_task(response['task_id'])