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

geobox/vectorlayer.py

@@ -18,7 +18,7 @@ if TYPE_CHECKING:
     from .file import File
     from .attachment import Attachment
     from .aio import AsyncGeoboxClient
-    from .aio.vectorlayer import VectorLayer as AsyncVectorLayer
+    from .aio.vectorlayer import AsyncVectorLayer
 
 
 class VectorLayer(Base):
@@ -333,7 +333,7 @@ class VectorLayer(Base):
             >>> layer = VectorLayer.get_vector(api=client, uuid="12345678-1234-5678-1234-567812345678")
             >>> layer.delete()
         """
-        super().delete(endpoint=self.endpoint)
+        super()._delete(endpoint=self.endpoint)
 
 
     def make_permanent(self) -> None:
@@ -1347,7 +1347,7 @@ class VectorLayer(Base):
             async_client (AsyncGeoboxClient): The async version of the GeoboxClient instance for making requests.
 
         Returns:
-            geobox.aio.vectorlayer.VectorLayer: the async instance of the vector layer.
+            AsyncVectorLayer: the async instance of the vector layer.
 
         Example:
             >>> from geobox import Geoboxclient
@@ -1358,111 +1358,6 @@ class VectorLayer(Base):
             >>> async with AsyncGeoboxClient() as async_client:
             >>>     async_layer = layer.to_async(async_client)
         """
-        from .aio.vectorlayer import VectorLayer as AsyncVectorLayer
+        from .aio.vectorlayer import AsyncVectorLayer
 
-        return AsyncVectorLayer(api=async_client, uuid=self.uuid, layer_type=self.layer_type, data=self.data)
-
-
-    def rasterize(self, 
-        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':
-        """
-        Rasterize a vector layer.
-
-        This method converts a vector layer (or view) to a raster dataset using the specified parameters. 
-        You can control the output raster's name, pixel size, data type, nodata value, and the value to burn (either a constant or from an attribute field). 
-        Only users with Publisher role or higher can perform this operation.
-
-        Args:
-            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
-            data_type (AnalysisDataType, optional): Data type for the output raster (e.g., int16, float32). default: AnalysisDataType.int16
-            burn_value (int, optional): Value to burn into the raster for all features (if burn_attribute is not set). default: 1
-            burn_attribute (str, optional): Name of the attribute field to use for burning values into the raster
-            user_id (int, optional): specific user. priviledges required!
-
-        Returns:
-            Task: task instance of the process
-
-        Example:
-            >>> from geobox import GeoboxClient
-            >>> client = GeoboxClient()
-            >>> vector = client.get_vector(uuid="12345678-1234-5678-1234-567812345678")
-            >>> task = vector.rasterize(output_raster_name='test')
-        """
-        from .analysis import Analysis
-        return Analysis.rasterize(self.api,
-                                    self,
-                                    output_raster_name=output_raster_name,
-                                    burn_attribute=burn_attribute,
-                                    pixel_size=pixel_size,
-                                    nodata=nodata,
-                                    data_type=data_type,
-                                    burn_value=burn_value,
-                                    user_id=user_id)
-
-
-    def idw_interpolation(self,
-        output_raster_name: str,
-        z_field: Field,
-        match_raster_uuid: Optional[str] = None,
-        pixel_size: int = 10,
-        extent: Optional[str] = None,
-        power: float = 2.0,
-        smoothing: float = 0.0,
-        max_points: int = 16,
-        radius: int = 1000,
-        nodata: int = -9999,
-        out_dtype: AnalysisDataType = AnalysisDataType.float32,
-        user_id: Optional[int] = None) -> 'Task':
-        """
-        Create an IDW (Inverse Distance Weighting) interpolation raster from point data.
-
-        it creates a raster using IDW interpolation from point data in a vector layer. 
-        Only users with Publisher role or higher can perform this operation.
-
-        Args:
-            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.
-            pixel_size (int, optional): Pixel size for the output raster. default: 10
-            extent (str, optional): Extent as 'minX,minY,maxX,maxY'.
-            power (float, optional): Power parameter for IDW. default: 2.0
-            smoothing (float, optional): Smoothing parameter for IDW. default: 0.0
-            max_points (int, optional): Maximum number of neighbors to use. default: 16
-            radius (int, optional): Search radius in map units. default: 1000
-            nodata (int, optional): NoData value for the output raster. default: -9999
-            out_dtype (AnalysisDataType, optional): Output data type.
-            user_id (int, optional): specific user. priviledges required!
-
-        Returns:
-            Task: task instance of the process
-
-        Example:
-            >>> from geobox import GeoboxClient
-            >>> client = GeoboxClient()
-            >>> vector = client.get_vector(uuid="12345678-1234-5678-1234-567812345678")
-            >>> field = vector.get_field_by_name('field_name')
-            >>> task = vector.idw(output_raster_name='test', z_field=field)
-        """
-        from .analysis import Analysis
-        return Analysis.idw_interpolation(self.api,
-            self,
-            output_raster_name=output_raster_name,
-            z_field=z_field,
-            match_raster_uuid=match_raster_uuid,
-            pixel_size=pixel_size,
-            extent=extent,
-            power=power,
-            smoothing=smoothing,
-            max_points=max_points,
-            radius=radius,
-            nodata=nodata,
-            out_dtype=out_dtype,
-            user_id=user_id)
+        return AsyncVectorLayer(api=async_client, uuid=self.uuid, layer_type=self.layer_type, data=self.data)