geobox 1.2.2__tar.gz → 1.2.3__tar.gz

{geobox-1.2.2 → geobox-1.2.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: geobox
-Version: 1.2.2
+Version: 1.2.3
 Summary: SDK for Geobox's APIs
 Author-email: Hamid Heydari <heydari.h62@gmail.com>
 License: MIT

{geobox-1.2.2 → geobox-1.2.3}/geobox/api.py

@@ -31,7 +31,7 @@ from .basemap import Basemap
 from .attachment import Attachment, AttachmentResourceType
 from .apikey import ApiKey
 from .log import Log
-from .usage import Usage
+from .usage import Usage, UsageScale, UsageParam
 
 logger = logging.getLogger(__name__)
 
@@ -500,6 +500,7 @@ class GeoboxClient:
                      display_name: str = None, 
                      description: str = None,
                      has_z: bool = False,
+                     temporary: bool = False,
                      fields: List = None) -> 'VectorLayer':
         """
         Create a new vector layer.
@@ -510,6 +511,7 @@ class GeoboxClient:
             display_name (str, optional): A human-readable name for the layer. default is None.
             description (str, optional): A description of the layer. default is None.
             has_z (bool, optional): Whether the layer includes Z coordinates. default is False.
+            temporary (bool, optional): Whether to create a temporary layer. temporary layers will be deleted after 24 hours. default is False.
             fields (List, optional): List of field definitions for the layer. default is None.
             
         Returns:
@@ -528,7 +530,7 @@ class GeoboxClient:
             ...                                 has_z=False,
             ...                                 fields=[{"name": "my_field", "datatype": "FieldTypeString"}])
         """
-        return VectorLayer.create_vector(self, name=name, layer_type=layer_type, display_name=display_name, description=description, has_z=has_z, fields=fields)
+        return VectorLayer.create_vector(self, name=name, layer_type=layer_type, display_name=display_name, description=description, has_z=has_z, temporary=temporary, fields=fields)
 
 
     def get_vector_by_name(self, name: str, user_id: int = None) -> Union['VectorLayer', None]:
@@ -760,7 +762,7 @@ class GeoboxClient:
         return VectorLayerView.get_view(self, uuid)
 
 
-    def get_view_by_name(self, name: str, user_id: int = None) -> Union['View', None]:
+    def get_view_by_name(self, name: str, user_id: int = None) -> Union['VectorLayerView', None]:
         """
         Get a view by name
 
@@ -769,7 +771,7 @@ class GeoboxClient:
             user_id (int, optional): specific user. privileges required.
 
         Returns:
-            View | None: returns the view if a view matches the given name, else None
+            VectorLayerView | None: returns the view if a view matches the given name, else None
 
         Example:
             >>> from geobox import GeoboxClient

{geobox-1.2.2 → geobox-1.2.3}/geobox/enums.py

@@ -134,20 +134,11 @@ class LayerType(Enum):
     Point = "Point"
     """A single point in 2D space"""
     
-    LineString = "LineString"
-    """A sequence of points forming a line"""
-    
-    Polygon = "Polygon"
-    """A closed shape defined by a sequence of points"""
-    
     MultiPoint = "MultiPoint"
     """A collection of points"""
     
-    MultiLineString = "MultiLineString"
-    """A collection of lines"""
-    
-    MultiPolygon = "MultiPolygon"
-    """A collection of polygons"""
+    Polygon = "Polygon"
+    """A closed shape defined by a sequence of points"""
 
     Polyline = "Polyline"
     """A polyline geometry"""
@@ -163,25 +154,22 @@ class FeatureType(Enum):
     """
     Point = "Point"
     """A single point in 2D space"""
+
+    MultiPoint = "MultiPoint"
+    """A collection of points"""
     
     LineString = "LineString"
     """A sequence of points forming a line"""
+
+    MultiLineString = "MultiLineString"
+    """A collection of lines"""
     
     Polygon = "Polygon"
     """A closed shape defined by a sequence of points"""
     
-    MultiPoint = "MultiPoint"
-    """A collection of points"""
-    
-    MultiLineString = "MultiLineString"
-    """A collection of lines"""
-    
     MultiPolygon = "MultiPolygon"
     """A collection of polygons"""
 
-    Polyline = "Polyline"
-    """A polyline geometry"""
-
 
 # Task Enums
 class TaskStatus(Enum):

{geobox-1.2.2 → geobox-1.2.3}/geobox/field.py

@@ -258,7 +258,7 @@ class Field(Base):
         Get the statistic of the field.
 
         Args:
-            func (str): The function to apply to the field.
+            func (str): The function to apply to the field. values are: min, max, avg
 
         Returns:
             Dict: The response data.
@@ -269,7 +269,7 @@ class Field(Base):
             >>> client = GeoboxClient()
             >>> layer = client.get_vector(uuid="12345678-1234-5678-1234-567812345678")
             >>> field = layer.get_field(name='test')
-            >>> field.get_field_statistic()
+            >>> field.get_field_statistic(func='avg')
         """
         endpoint = urljoin(self.endpoint, f'stats/?func_type={func}')
         return self.layer.api.get(endpoint)

{geobox-1.2.2 → geobox-1.2.3}/geobox/map.py

@@ -621,31 +621,32 @@ class Map(Base):
         grid_settings = {'enable_grid', 'grid_unit', 'grid_width', 'grid_height', 'grid_minzoom', 'grid_maxzoom'}
         view_settings = {'bearing', 'pitch', 'center', 'zoom'}
 
+        settings = self.settings
+
         for key, value in kwargs.items():
             if key in general_settings:
-                self.settings['general_settings'][key] = value
+                settings['general_settings'][key] = value
             elif key in edit_settings:
-                self.settings['edit_settings'][key] = value
+                settings['edit_settings'][key] = value
             elif key in snap_settings:
-                self.settings['snap_settings'][key] = value
+                settings['snap_settings'][key] = value
             elif key == 'controls':
-                self.settings['controls'] = value
+                settings['controls'] = value
             elif key in search_settings:
-                self.settings['search_settings'][key] = value
+                settings['search_settings'][key] = value
             elif key in marker_settings:
-                self.settings['marker_settings'][key] = value
+                settings['marker_settings'][key] = value
             elif key in terrain_settings:
-                self.settings['terrain_settings'][key] = value
+                settings['terrain_settings'][key] = value
             elif key in grid_settings:
-                self.settings['grid_settings'][key] = value
+                settings['grid_settings'][key] = value
             elif key in view_settings:
-                self.settings['view_settings'][key] = value
+                settings['view_settings'][key] = value
             elif key == 'toc_settings':
-                self.settings['toc_settings'] = value
+                settings['toc_settings'] = value
+
+        return super()._set_settings(self.endpoint, settings)    
 
-        endpoint = urljoin(self.endpoint, 'settings/')
-        self.api.put(endpoint, self.settings)
-    
 
     def get_markers(self) -> Dict:
         """

{geobox-1.2.2 → geobox-1.2.3}/geobox/raster.py

@@ -608,10 +608,7 @@ class Raster(Base):
             'min_zoom', 'max_zoom', 'use_cache', 'cache_until_zoom'
         }
 
-        settings = {
-            'visual_settings': {},
-            'tile_settings': {}
-        }
+        settings = self.settings
 
         for key, value in kwargs.items():
             if key in visual_settings:
@@ -620,7 +617,7 @@ class Raster(Base):
                 settings['tile_settings'][key] = value
 
 
-        super()._set_settings(self.endpoint, settings)
+        return super()._set_settings(self.endpoint, settings)
 
 
     def share(self, users: List['User']) -> None:

{geobox-1.2.2 → geobox-1.2.3}/geobox/task.py

@@ -10,6 +10,7 @@ if TYPE_CHECKING:
     from .vectorlayer import VectorLayer
     from .raster import Raster
     from .model3d import Model
+    from .file import File
 
 class Task(Base):
     """
@@ -45,9 +46,9 @@ class Task(Base):
 
 
     @property
-    def publised_asset(self) -> Union['VectorLayer', 'Raster', 'Model', None]:
+    def output_asset(self) -> Union['VectorLayer', 'Raster', 'Model', 'File', None]:
         """
-        Published asset property
+        output asset property
 
         Returns:
             VectorLayer | Raster | Model | None: if task type is publish, it returns the published layer
@@ -57,14 +58,20 @@ class Task(Base):
             >>> from geobox.task import Task
             >>> client = GeoboxClient()
             >>> task = Task.get_task(client, uuid="12345678-1234-5678-1234-567812345678")
-            >>> task.publised_asset
+            >>> task.output_asset
         """
-        if self.name == 'import:publish-file-to-raster-dataset':
-            return self.api.get_raster(uuid=self.data['result']['raster_uuid'])
-        elif self.name == 'import:publish-file-to-vector-layer':
+        if self.data.get('result', {}).get('layer_uuid'):
             return self.api.get_vector(uuid=self.data['result']['layer_uuid'])
-        elif self.name == 'import:publish-file-to-3d-model':
+
+        elif self.data.get('result', {}).get('raster_uuid'):
+            return self.api.get_raster(uuid=self.data['result']['raster_uuid'])
+
+        elif self.data.get('result', {}).get('model_uuid'):
             return self.api.get_model(uuid=self.data['result']['model_uuid'])
+
+        elif self.data.get('result', {}).get('file_uuid'):
+            return self.api.get_file(uuid=self.data['result']['file_uuid'])
+
         else:
             return None
 

{geobox-1.2.2 → geobox-1.2.3}/geobox/vectorlayer.py

@@ -16,6 +16,7 @@ if TYPE_CHECKING:
     from .api import GeoboxClient
     from .view import VectorLayerView
     from .user import User
+    from .file import File
 
 class VectorLayer(Base):
     """
@@ -226,6 +227,7 @@ class VectorLayer(Base):
                      display_name: str = None,
                      description: str = None, 
                      has_z: bool = False, 
+                     temporary: bool = False,
                      fields: List = None) -> 'VectorLayer':
         """
         Create a new vector layer.
@@ -237,6 +239,7 @@ class VectorLayer(Base):
             display_name (str, optional): A human-readable name for the layer. default is None.
             description (str, optional): A description of the layer. default is None.
             has_z (bool, optional): Whether the layer includes Z coordinates. default is False.
+            temporary (bool, optional): Whether to create a temporary layer. temporary layers will be deleted after 24 hours. default is False.
             fields (List, optional): List of field definitions for the layer. default is None.
             
         Returns:
@@ -255,6 +258,7 @@ class VectorLayer(Base):
             ...                                 display_name="My Layer",
             ...                                 description="This is a description of my layer",
             ...                                 has_z=False,
+            ...                                 temporary=True,
             ...                                 fields=[{"name": "my_field", "datatype": "FieldTypeString"}])
             or
             >>> layer = client.create_vector(name="my_layer", 
@@ -262,6 +266,7 @@ class VectorLayer(Base):
             ...                                 display_name="My Layer",
             ...                                 description="This is a description of my layer",
             ...                                 has_z=False,
+            ...                                 temporary=True,
             ...                                 fields=[{"name": "my_field", "datatype": "FieldTypeString"}])
         """
         data = {
@@ -270,6 +275,7 @@ class VectorLayer(Base):
             "display_name": display_name,
             "description": description,
             "has_z": has_z,
+            "temporary": temporary,
             "fields": fields
         }
         return super()._create(api=api, 
@@ -332,7 +338,8 @@ class VectorLayer(Base):
         Make the layer permanent.
         """
         endpoint = urljoin(self.endpoint, 'makePermanent/')
-        self.api.post(endpoint, is_json=False)
+        response = self.api.post(endpoint, is_json=False)
+        self._update_properties(response)
 
 
     def share(self, users: List['User']) -> None:
@@ -470,41 +477,56 @@ class VectorLayer(Base):
                             factory_func=lambda api, item: Field(layer=self, data_type=FieldType(item['datatype']), field_id=item['id'], data=item))
 
 
-    def get_field(self, field_id: str = None, name: str = None) -> 'Field':
+    def get_field(self, field_id: int) -> 'Field':
         """
         Get a specific field by its ID.
         
         Args:
-            field_id (str, optional): The ID of the field to retrieve.
-            name (str, optional): The name of the field to retrieve.
+            field_id (int, optional): The ID of the field to retrieve.
 
         Returns:
             Field: The requested field instance.
             
         Raises:
-            ValueError: Either id or name must be provided.
-            NotFoundError: If the field with the specified ID or name is not found. 
+            NotFoundError: If the field with the specified ID is not found. 
 
         Example:
             >>> from geobox import GeoboxClient
             >>> from geobox.vectorlayer import VectorLayer
             >>> client = GeoboxClient()
             >>> layer = VectorLayer.get_vector(api=client, uuid="12345678-1234-5678-1234-567812345678")
-            >>> field = layer.get_field(field_id="1")
+            >>> field = layer.get_field(field_id=1)
+        """        
+        field = next((f for f in self.get_fields() if f.id == field_id), None)
+        if not field:
+            raise NotFoundError(f'Field with ID {field_id} not found in layer {self.name}')
+            
+        return field
+
+
+    def get_field_by_name(self, name: str) -> 'Field':
         """
-        if not (field_id or name):
-            raise ValueError('Either "field_id" or "name" must be provided')
+        Get a specific field by its name.
         
-        if field_id:
-            field = next((f for f in self.get_fields() if str(f.id) == str(field_id)), None)
-        elif name:
-            field = next((f for f in self.get_fields() if f.name == name), None)
+        Args:
+            name (str, optional): The name of the field to retrieve.
 
+        Returns:
+            Field: The requested field instance.
+            
+        Raises:
+            NotFoundError: If the field with the specified name is not found. 
+
+        Example:
+            >>> from geobox import GeoboxClient
+            >>> from geobox.vectorlayer import VectorLayer
+            >>> client = GeoboxClient()
+            >>> layer = VectorLayer.get_vector(api=client, uuid="12345678-1234-5678-1234-567812345678")
+            >>> field = layer.get_field_by_name(name='test')
+        """        
+        field = next((f for f in self.get_fields() if f.name == name), None)
         if not field:
-            if field_id:
-                raise NotFoundError(f'Field with ID {field_id} not found in layer {self.name}')
-            elif name:
-                raise NotFoundError(f'Field with name "{name}" not found in layer {self.name}')
+            raise NotFoundError(f"Field with name '{name}' not found in layer {self.name}")
             
         return field
 
@@ -542,7 +564,7 @@ class VectorLayer(Base):
                         bbox_srid: int = None, 
                         feature_ids: List = None, 
                         run_async: bool = True, 
-                        user_id: int = None) -> 'Task':
+                        user_id: int = None) -> Union['Task', Dict]:
         """
         Calculate values for a field based on an expression.
         
@@ -557,7 +579,7 @@ class VectorLayer(Base):
             user_id (int, optional): Specific user. privileges required.
             
         Returns:
-            Task: The task instance of the calculation operation.
+            Task | Dict: The task instance of the calculation operation or the api response if the run_async=False.
 
         Example:
             >>> from geobox import GeoboxClient
@@ -585,8 +607,11 @@ class VectorLayer(Base):
         
         endpoint = urljoin(self.endpoint, 'calculateField/')
         response = self.api.post(endpoint, data, is_json=False)
-        task = Task.get_task(self.api, response.get('task_uuid'))
-        return task
+        if run_async:
+            task = Task.get_task(self.api, response.get('task_id'))
+            return task
+
+        return response
 
 
     def get_features(self, **kwargs) -> Union[List['Feature'], int]:
@@ -713,21 +738,21 @@ class VectorLayer(Base):
         return Feature.create_feature(self, geojson)
 
 
-    def delete_features(self, q: str = None, bbox: List[float] = None, bbox_srid: int = None, feature_ids: List[int] = None, 
-                        run_async: bool = True, user_id: int = None) -> 'Task':
+    def delete_features(self, q: str = None, bbox: str = None, bbox_srid: int = None, feature_ids: List[int] = None, 
+                        run_async: bool = True, user_id: int = None) -> Union['Task', Dict]:
         """
         Delete features from the layer based on specified criteria.
         
         Args:
-            q (Optional[str]): Query to filter features to delete.
-            bbox (Optional[List[float]]): Bounding box to filter features.
-            bbox_srid (Optional[int]): Spatial reference ID for the bounding box.
-            feature_ids (Optional[List[int]]): List of specific feature IDs to delete.
-            run_async (Optional[bool]): Whether to run the deletion asynchronously. default is True.
-            user_id (Optional[int]): Specific user. privileges required.
+            q (str, optional): Query to filter features to delete.
+            bbox (str, optional): Comma seprated bbox.
+            bbox_srid (int, optional): Spatial reference ID for the bounding box.
+            feature_ids (str, optional): Comma seprated feature ids.
+            run_async (bool, optional): Whether to run the deletion asynchronously. default is True.
+            user_id (int, optional): Specific user. privileges required.
             
         Returns:
-            Task: The task instance of the deletion operation.
+            Task | Dict: The task instance of the deletion operation or the api response if run_async=False.
             
         Raises:
             ValidationError: If the deletion parameters are invalid.
@@ -738,9 +763,9 @@ class VectorLayer(Base):
             >>> client = GeoboxClient()
             >>> layer = VectorLayer.get_vector(api=client, uuid="12345678-1234-5678-1234-567812345678")
             >>> layer.delete_features(q="name like 'my_layer'", 
-            ...                         bbox=[10, 20, 30, 40],
+            ...                         bbox='10, 20, 30, 40',
             ...                         bbox_srid=3857, 
-            ...                         feature_ids=[1, 2, 3], 
+            ...                         feature_ids='1, 2, 3', 
             ...                         run_async=True)
         """
         data = clean_data({
@@ -754,19 +779,29 @@ class VectorLayer(Base):
 
         endpoint = urljoin(self.endpoint, 'deleteFeatures/')
         response = self.api.post(endpoint, data, is_json=False)
-        task = Task.get_task(self.api, response.get('task_id'))
-        return task
+        if run_async:
+            task = Task.get_task(self.api, response.get('task_id'))
+            return task
 
+        return response
 
-    def import_features(self, file_uuid: str, input_geom_type: 'InputGeomType', input_layer_name: str = None, input_dataset: str = None, 
-                        user_id: int = None, input_srid: int = None, file_encoding: str = "utf-8", 
-                        replace_domain_codes_by_values: bool = False, report_errors: bool = True) -> 'Task':
+
+    def import_features(self, 
+                            file: 'File', 
+                            input_geom_type: 'InputGeomType' = None, 
+                            input_layer_name: str = None, 
+                            input_dataset: str = None, 
+                            user_id: int = None, 
+                            input_srid: int = None, 
+                            file_encoding: str = "utf-8", 
+                            replace_domain_codes_by_values: bool = False, 
+                            report_errors: bool = True) -> 'Task':
         """
         Import features from a file into the layer.
         
         Args:
-            file_uuid (str): UUID of the uploaded file to import.
-            input_geom_type (InputGeomType): Type of geometry in the input file.
+            file (File): file object to import.
+            input_geom_type (InputGeomType, optional): Type of geometry in the input file.
             input_layer_name (str, optional): Name of the layer in the input file.
             input_dataset (str, optional): Name of the dataset in the input file.
             user_id (int, optional): Specific user. privileges required.
@@ -786,7 +821,8 @@ class VectorLayer(Base):
             >>> from geobox.vectorlayer import VectorLayer
             >>> client = GeoboxClient()
             >>> layer = VectorLayer.get_vector(api=client, uuid="12345678-1234-5678-1234-567812345678")
-            >>> task = layer.import_features(file_uuid="12345678-1234-5678-1234-567812345678", 
+            >>> file = client.get_file(uuid="12345678-1234-5678-1234-567812345678")
+            >>> task = layer.import_features(file=file, 
             ...                         input_geom_type=InputGeomType.POINT,
             ...                         input_layer_name="my_layer",
             ...                         input_dataset="my_dataset",
@@ -796,7 +832,7 @@ class VectorLayer(Base):
             ...                         report_errors=True)
         """
         data = clean_data({
-            "file_uuid": file_uuid,
+            "file_uuid": file.uuid,
             "input_layer": input_layer_name,
             "input_geom_type": input_geom_type.value if isinstance(input_geom_type, InputGeomType) else input_geom_type,
             "replace_domain_codes_by_values": replace_domain_codes_by_values,
@@ -813,9 +849,17 @@ class VectorLayer(Base):
         return task
 
 
-    def export_features(self, out_filename: str, out_format: 'FileOutputFormat', replace_domain_codes_by_values: bool = False, 
-                        run_async: bool = True, bbox: List[float] = None, out_srid: int = None, zipped: bool = True, 
-                        feature_ids: List[int] = None, bbox_srid: int = None, q: str = None, fields: List[str] = None) -> 'Task':
+    def export_features(self, 
+                            out_filename: str, 
+                            out_format: 'FileOutputFormat', 
+                            replace_domain_codes_by_values: bool = False, 
+                            run_async: bool = True, 
+                            bbox: List[float] = None, 
+                            out_srid: int = None, 
+                            zipped: bool = True, 
+                            feature_ids: List[int] = None, 
+                            bbox_srid: int = None, 
+                            q: str = None, fields: List[str] = None) -> Union['Task', Dict]:
         """
         Export features from the layer to a file.
         
@@ -833,7 +877,7 @@ class VectorLayer(Base):
             fields (List[str], optional): List of fields to include in the export.
             
         Returns:
-            Task: The task instance of the export operation.
+            Task | Dict: The task instance of the export operation or the api response if run_async=False.
             
         Raises:
             ValidationError: If the export parameters are invalid.
@@ -868,8 +912,11 @@ class VectorLayer(Base):
 
         endpoint = urljoin(self.endpoint, 'export/')
         response = self.api.post(endpoint, data, is_json=False)
-        task = Task.get_task(self.api, response.get('task_id'))
-        return task
+        if run_async:
+            task = Task.get_task(self.api, response.get('task_id'))
+            return task
+
+        return response
 
 
     def create_view(self, name: str, display_name: str = None, description: str = None, 
@@ -1031,11 +1078,7 @@ class VectorLayer(Base):
         edit_settings = {'editable', 'edit_geometry', 'editable_attributes', 'allow_insert', 'allow_delete'}
         tile_settings = {'min_zoom', 'max_zoom', 'max_features', 'filter_features', 'fields', 'use_cache', 'cache_until_zoom'}
 
-        settings = {
-            'general_settings': {},
-            'edit_settings': {},
-            'tile_settings': {}
-        }
+        settings = self.settings
 
         for key, value in kwargs.items():
             if key in general_settings: