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

geobox/aio/task.py

@@ -250,7 +250,7 @@ class Task(AsyncBase):
 
     def _check_timeout(self, start_time: float, timeout: Union[int, None]) -> None:
         """Checks if the task has exceeded the timeout period."""
-        if timeout and time.time() - start_time > timeout:
+        if timeout and time.time() - start_time > float(timeout):
             raise TimeoutError(f"Task {self.name} timed out after {timeout} seconds")
 
 

geobox/aio/usage.py

@@ -168,7 +168,7 @@ class Usage(AsyncBase):
             user_id (int, optional): the id of the user. leave blank to get the current user report.
 
         Returns:
-            Dict: the usage summery of the users
+            Dict: the usage summary of the users
 
         Returns:
             >>> from geobox.aio import AsyncGeoboxClient

geobox/aio/vectorlayer.py

@@ -8,7 +8,7 @@ from .task import Task
 from .version import VectorLayerVersion
 from ..utils import clean_data
 from ..exception import NotFoundError
-from ..enums import LayerType, InputGeomType, FileOutputFormat
+from ..enums import LayerType, InputGeomType, FileOutputFormat, AnalysisDataType
 
 if TYPE_CHECKING:
     from .api import AsyncGeoboxClient
@@ -1360,4 +1360,111 @@ class VectorLayer(AsyncBase):
         """
         from ..vectorlayer import VectorLayer as SyncVectorLayer
 
-        return SyncVectorLayer(api=sync_client, uuid=self.uuid, layer_type=self.layer_type, data=self.data)
+        return SyncVectorLayer(api=sync_client, uuid=self.uuid, layer_type=self.layer_type, data=self.data)
+
+
+
+
+    async 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':
+        """
+        [async] 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.aio import AsyncGeoboxClient
+            >>> async with AsyncGeoboxClient() as client:
+            >>>     vector = await client.get_vector(uuid="12345678-1234-5678-1234-567812345678")
+            >>>     task = await vector.rasterize(output_raster_name='test')
+        """
+        from .analysis import Analysis
+        return await 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)
+
+
+    async 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':
+        """
+        [async] 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.aio import AsyncGeoboxClient
+            >>> 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 vector.idw(output_raster_name='test', z_field=field)
+        """
+        from .analysis import Analysis
+        return await 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)

geobox/aio/workflow.py

@@ -92,7 +92,7 @@ class Workflow(AsyncBase):
             description (str): The description of the workflow.
             settings (Dict): The settings of the workflow.
             thumbnail (str): The thumbnail of the workflow.
-            user_id (int): Specific user. privileges workflow.
+            user_id (int): Specific user. privileges required.
 
         Returns:
             Workflow: The newly created workflow instance.