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

geobox/raster.py

@@ -18,7 +18,7 @@ if TYPE_CHECKING:
     from . import GeoboxClient 
     from .user import User
     from .aio import AsyncGeoboxClient
-    from .aio.raster import Raster as AsyncRaster
+    from .aio.raster import AsyncRaster
 
 class Raster(Base):
 
@@ -214,7 +214,7 @@ class Raster(Base):
             >>> raster = Raster.get_raster(client, uuid="12345678-1234-5678-1234-567812345678")
             >>> raster.delete()
         """
-        super().delete(self.endpoint)
+        super()._delete(self.endpoint)
     
 
     @property
@@ -232,7 +232,7 @@ class Raster(Base):
             >>> raster = Raster.get_raster(client, uuid="12345678-1234-5678-1234-567812345678")
             >>> raster.thumbnail
         """
-        return super().thumbnail(format='')
+        return super()._thumbnail(format='')
     
     
     @property
@@ -852,7 +852,7 @@ class Raster(Base):
             async_client (AsyncGeoboxClient): The async version of the GeoboxClient instance for making requests.
 
         Returns:
-            geobox.aio.raster.Raster: the async instance of the raster.
+            AsyncRaster: the async instance of the raster.
 
         Example:
             >>> from geobox import Geoboxclient
@@ -863,374 +863,11 @@ class Raster(Base):
             >>> async with AsyncGeoboxClient() as async_client:
             >>>     async_raster = raster.to_async(async_client)
         """
-        from .aio.raster import Raster as AsyncRaster
+        from .aio.raster import AsyncRaster
 
         return AsyncRaster(api=async_client, uuid=self.uuid, data=self.data)
 
 
-    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':
-        """
-        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 import GeoboxClient
-            >>> client = GeoboxClient()
-            >>> raster = client.get_raster(uuid="12345678-1234-5678-1234-567812345678")
-            >>> raster.polygonize(output_layer_name='test')
-        """
-        from .analysis import Analysis
-        return 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)
-
-
-    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':
-        """
-        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 import GeoboxClient
-            >>> client = GeoboxClient()
-            >>> raster = client.get_raster(uuid="12345678-1234-5678-1234-567812345678")
-            >>> vector = client.get_vector(uuid="12345678-1234-5678-1234-567812345678")
-            >>> raster.clip(layer=vector, output_raster_name='test')
-        """
-        from .analysis import Analysis
-        return 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)
-
-
-    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':
-        """
-        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 import GeoboxClient
-            >>> client = GeoboxClient()
-            >>> raster = client.get_raster(uuid="12345678-1234-5678-1234-567812345678")
-            >>> raster.slope(output_raster_name='test')
-        """
-        from .analysis import Analysis
-        return 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)
-
-
-    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':
-        """
-        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 import GeoboxClient
-            >>> client = GeoboxClient()
-            >>> raster = client.get_raster(uuid="12345678-1234-5678-1234-567812345678")
-            >>> raster.aspect(output_raster_name='test')
-        """
-        from .analysis import Analysis
-        return Analysis.aspect(self.api,
-            self,
-            output_raster_name=output_raster_name,
-            algorithm=algorithm,
-            trigonometric=trigonometric,
-            zero_for_flat=zero_for_flat,
-            compute_edges=compute_edges,
-            nodata_out=nodata_out,
-            user_id=user_id)
-
-
-    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':
-        """
-        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 import GeoboxClient
-            >>> client = GeoboxClient()
-            >>> raster = client.get_raster(uuid="12345678-1234-5678-1234-567812345678")
-            >>> raster.reclassify(output_raster_name='test', rules='{"1": 10, "2": 20, "3": 30}')
-        """
-        from .analysis import Analysis
-        return 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)
-
-
-    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':
-        """
-        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!
-
-        Returns:
-            Task: task instance of the process
-
-        Example:
-            >>> from geobox import GeoboxClient
-            >>> client = GeoboxClient()
-            >>> raster = client.get_raster(uuid="12345678-1234-5678-1234-567812345678")
-            >>> raster.resample(output_raster_name='test')
-        """
-        from .analysis import Analysis
-        return 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)
-
-
-    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':
-        """
-        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 import GeoboxClient
-            >>> client = GeoboxClient()
-            >>> raster = client.get_raster(uuid="12345678-1234-5678-1234-567812345678")
-            >>> task = raster.fill_nodata(output_raster_name='test')
-        """
-        from .analysis import Analysis
-        return 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)
-
-
-    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':
-        """
-        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 import GeoboxClient
-            >>> client = GeoboxClient()
-            >>> raster = client.get_raster(uuid="12345678-1234-5678-1234-567812345678")
-            >>> task = raster.proximity(output_raster_name='test')
-        """
-        from .analysis import Analysis
-        return 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)
-
-
     def profile(self,
         polyline: List,
         number_of_samples: int = 100,