geobox 1.2.2__py3-none-any.whl → 1.3.0__py3-none-any.whl

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/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):
@@ -269,7 +257,7 @@ class UserRole(Enum):
 
     EDITOR = "Editor"
 
-    VIEWR = "Viewer"
+    VIEWER = "Viewer"
 
 
 class UserStatus(Enum):

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/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/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/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/user.py

@@ -36,6 +36,17 @@ class User(Base):
             str: A string representation of the User instance.
         """
         return f'User(id={self.id}, first_name={self.first_name}, last_name={self.last_name})'
+
+
+    @property
+    def role(self) -> 'UserRole':
+        """
+        User role property
+
+        Returns:
+            UserRole: the user role
+        """
+        return UserRole(self.data.get('role')) if self.data.get('role') else None
     
 
     @property
@@ -94,6 +105,7 @@ class User(Base):
         """
         params = {
            'f': 'json',
+           'status': kwargs.get('status').value if kwargs.get('status') else None,
            'q': kwargs.get('q'),
            'search': kwargs.get('search'),
            'search_fields': kwargs.get('search_fields'),
@@ -264,18 +276,33 @@ class User(Base):
             >>> user.update_user(status=UserStatus.PENDING)
         """
         data = {
-            "csrf_token": kwargs.get('csrf_token'),
             "username": kwargs.get('username'),
             "email": kwargs.get('email'),
             "first_name": kwargs.get('first_name'),
             "last_name": kwargs.get('last_name'),
-            "mobile": kwargs.get('mobile'),
             "status": kwargs.get('status').value if kwargs.get('status') else None,
             "role": kwargs.get('role').value if kwargs.get('role') else None,
-            "plan_id": kwargs.get('plan').id if kwargs.get('plan') else None,
-            "expiration_date": kwargs.get('expiration_date')
         }
-        return super()._update(self.endpoint, data)
+        data = clean_data(data)
+
+        try:
+            data['mobile'] = None if kwargs['mobile'] == '' else kwargs['mobile']
+        except:
+            pass
+
+        try:
+            data['plan_id'] = None if kwargs['plan'] == '' else kwargs['plan'].id
+        except:
+            pass
+
+        try:
+            data['expiration_date'] = None if kwargs['expiration_date'] == '' else kwargs['expiration_date']
+        except:
+            pass
+
+        response = self.api.put(self.endpoint, data)
+        self._update_properties(response)
+        return response
     
 
     def delete(self) -> None:

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:
@@ -447,7 +454,10 @@ class VectorLayer(Base):
             >>> layer = VectorLayer.get_vector(api=client, uuid="12345678-1234-5678-1234-567812345678")
             >>> layer.wfs
         """
-        return f'{self.api.base_url}{self.endpoint}wfs/'
+        if self.api.access_token:
+            return f'{self.api.base_url}{self.endpoint}wfs/'
+        elif self.api.apikey:
+            return f'{self.api.base_url}{self.endpoint}apikey:{self.api.apikey}/wfs/'
 
 
     def get_fields(self) -> List['Field']:
@@ -470,41 +480,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 +567,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 +582,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 +610,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 +741,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 +766,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 +782,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 +824,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 +835,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 +852,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 +880,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 +915,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 +1081,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:

geobox/view.py

@@ -9,6 +9,7 @@ if TYPE_CHECKING:
     from .user import User
     from .enums import InputGeomType, FieldType
     from .task import Task
+    from .file import File
 
 
 class VectorLayerView(VectorLayer):
@@ -163,7 +164,7 @@ class VectorLayerView(VectorLayer):
             'include_settings': include_settings
         }
         return super()._get_list_by_ids(api=api, 
-                                        endpoint=f'{cls.BASE_ENDPOINT}get-views/', 
+                                        endpoint=f'{cls.BASE_ENDPOINT}get-layers/', 
                                         params=params, 
                                         factory_func=lambda api, item: VectorLayerView(api, item['uuid'], LayerType(item['layer_type']), item))
 
@@ -201,7 +202,7 @@ class VectorLayerView(VectorLayer):
 
 
     @classmethod
-    def get_view_by_name(cls, api: 'GeoboxClient', name: str, user_id: int = None) -> Union['View', None]:
+    def get_view_by_name(cls, api: 'GeoboxClient', name: str, user_id: int = None) -> Union['VectorLayerView', None]:
         """
         Get a view by name
 
@@ -211,7 +212,7 @@ class VectorLayerView(VectorLayer):
             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
@@ -361,13 +362,12 @@ class VectorLayerView(VectorLayer):
         return super().get_fields()
     
 
-    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 or name.
         
         Args:
-            field_id (str): The ID of the field to retrieve.
-            name (str): The name of the field to retrieve.
+            field_id (int): The ID of the field to retrieve.
 
         Returns:
             Field: The requested field instance.
@@ -381,40 +381,37 @@ class VectorLayerView(VectorLayer):
             >>> from geobox.view import VectorLayerView
             >>> client = GeoboxClient()
             >>> view = VectorLayerView.get_view(client, uuid="12345678-1234-5678-1234-567812345678")
-            >>> field = view.get_field(id="1")
+            >>> field = view.get_field(id=1)
         """
-        return super().get_field(field_id, name)
+        return super().get_field(field_id)
 
 
-    def add_field(self, name: str, data_type: 'FieldType', data: Dict = {}) -> 'Field':
+    def get_field_by_name(self, name: str) -> 'Field':
         """
-        Add a new field to the vector layer view.
+        Get a specific field by its name.
         
         Args:
-            name (str): The name of the new field.
-            data_type (FieldType): The data type of the new field.
-            data (Dict): Additional field properties (display_name, description, etc.).
-            
+            name (str, optional): The name of the field to retrieve.
+
         Returns:
-            Field: The newly created field instance.
+            Field: The requested field instance.
             
         Raises:
-            ValidationError: If the field data is invalid.
-            ApiRequestError: If the API request fails.
+            NotFoundError: If the field with the specified name is not found. 
 
         Example:
             >>> from geobox import GeoboxClient
             >>> from geobox.view import VectorLayerView
             >>> client = GeoboxClient()
             >>> view = VectorLayerView.get_view(client, uuid="12345678-1234-5678-1234-567812345678")
-            >>> field = view.add_field(name="new_field", data_type=FieldType.String)
-        """
-        return  super().add_field(name, data_type, data)
+            >>> field = view.get_field_by_name(name='test')
+        """      
+        return super().get_field_by_name(name)
     
 
     def calculate_field(self, target_field: str, expression: str, q: str = None, bbox: List[float] = None, 
                         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.
         
@@ -429,7 +426,7 @@ class VectorLayerView(VectorLayer):
             user_id (Optional[int]): ID of the user running the calculation.
             
         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.
             
         Raises:
             ValidationError: If the calculation parameters are invalid.
@@ -541,7 +538,7 @@ class VectorLayerView(VectorLayer):
 
 
     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':
+                        run_async: bool = True, user_id: int = None) -> Union['Task', Dict]:
         """
         Delete features from the layer based on specified criteria.
         
@@ -554,7 +551,7 @@ class VectorLayerView(VectorLayer):
             user_id (Optional[int]): ID of the user performing the deletion.
             
         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.
@@ -573,15 +570,22 @@ class VectorLayerView(VectorLayer):
         return super().delete_features(q, bbox, bbox_srid, feature_ids, run_async, user_id)
 
 
-    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 requied.
@@ -601,7 +605,8 @@ class VectorLayerView(VectorLayer):
             >>> from geobox.view import VectorLayerView
             >>> client = GeoboxClient()
             >>> view = VectorLayerView.get_view(client, uuid="12345678-1234-5678-1234-567812345678")
-            >>> task = view.import_features(file_uuid="12345678-1234-5678-1234-567812345678", 
+            >>> file = client.get_file(uuid="12345678-1234-5678-1234-567812345678")
+            >>> task = view.import_features(file=file, 
             ...                         input_geom_type=InputGeomType.POINT,
             ...                         input_layer="my_layer",
             ...                         input_dataset="my_dataset",
@@ -610,13 +615,13 @@ class VectorLayerView(VectorLayer):
             ...                         replace_domain_codes_by_values=False, 
             ...                         report_errors=True)
         """
-        return super().import_features(file_uuid, input_geom_type, input_layer_name, input_dataset, user_id, 
+        return super().import_features(file, input_geom_type, input_layer_name, input_dataset, user_id, 
                                        input_srid, file_encoding, replace_domain_codes_by_values, report_errors)
 
 
     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':
+                        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.
         
@@ -634,7 +639,7 @@ class VectorLayerView(VectorLayer):
             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.

{geobox-1.2.2.dist-info → geobox-1.3.0.dist-info}/METADATA

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

{geobox-1.2.2.dist-info → geobox-1.3.0.dist-info}/RECORD

@@ -1,37 +1,37 @@
 geobox/__init__.py,sha256=iRkJAFIjMXiAaLTVXvZcW5HM7ttyipGdxFZ15NCM8qU,1895
-geobox/api.py,sha256=Sq9iKYltgdR96cA4w5_5jMraNqAUpgSzMriO9PbZFNA,100538
+geobox/api.py,sha256=v-_Vay_xIXZRG3-0ahiOWxVT9QkrIyuOcd2KYFyVK04,100795
 geobox/apikey.py,sha256=FBio1PtGovAUaTE0HW9IJ55UuFdR_1ICk_FQhHu5dAE,7427
 geobox/attachment.py,sha256=XbGwfWWuFAMimj4tsjKBvlSLP-rhpNACCtxgRmUvcdY,11631
 geobox/base.py,sha256=p0UVZo9CINw0mW9o0nNR_VNCk7V1r-FrLQ_NH39WARE,12299
 geobox/basemap.py,sha256=fDWwkMf-F2NTE1tVLijoxQku55825b6gj8nk69TMOII,4386
 geobox/dashboard.py,sha256=MYyT3YJEGPCbTXHcYoZmn14rFOaut1J3idEA8bCdFgI,11762
-geobox/enums.py,sha256=jGs8GzyCzQMJ5go9owDKMiAwuWjDCpKPaNmQg2eiCaQ,6613
+geobox/enums.py,sha256=eYD-SVXCSp4l08DlxymJTqYzTLouRziWhLZd7letnTM,6317
 geobox/exception.py,sha256=jvpnv0M2Ck1FpxHTL_aKYWxGvLnCQ3d9vOrMIktjw1U,1507
 geobox/feature.py,sha256=3Kbc1LjIkBt1YqRAry84BrR7qxx9BexvBB3YQ8D9mGk,18504
-geobox/field.py,sha256=2VxjeYgRwnDxHYpAsK0ASOCz8V0JmfTA3GqHDv3rfgQ,10526
+geobox/field.py,sha256=p9eitUpnsiGj6GUhjSomk6HWlsNJSbE-Oh_4VcjaqVo,10562
 geobox/file.py,sha256=Ula8r8pZaCmifsnUHDbaJujw53SLxUiCiBzVS358o88,19967
 geobox/log.py,sha256=ZTmVErhyAszf7M5YFxT5mqXNNDGPnRwXPeGLDS1G6PE,3582
-geobox/map.py,sha256=98P1gbB5U_eu71Hu6EQ0kL_ponbPAnoOCitjEa35q4I,31307
+geobox/map.py,sha256=RjuhbOVQN-OBwjBtO46AosB_Ta348EA1nExBdnxH3nw,31252
 geobox/model3d.py,sha256=qRYCx-q9LpGhdu5oz3av0uUoiDimuk4BvXXwMW5bo9Q,12061
 geobox/mosaic.py,sha256=RmMyvzt6C2Fd8a0nJX5gUOGJnO3MrCWgwmYfhJ9d_Jw,23025
 geobox/plan.py,sha256=_ZV9F6loG92uQZGJl_9T08Kg85g3hnODmpccSkTYVdw,11193
 geobox/query.py,sha256=1guO9O9DAEb8oj_iMiW3PhEDgMVMAN9ccEp19dnwAWE,24209
-geobox/raster.py,sha256=9Qnv9CQvgVxuNx1khDPQhHZEcopXofIPYBnRrx40FVk,26495
+geobox/raster.py,sha256=DkvajG2jWDlGFbS2ywv4XCVOyfR82ouUMT3tdIE1PsU,26437
 geobox/route.py,sha256=cKZTTHBHM8woWbhHIpCvrRX_doJcTkGktouee0z7oG0,2723
 geobox/scene.py,sha256=Sz2tiyJk-bXYjktfcp1d2gGrW3gt2T4D1FAMoRHOCng,11369
 geobox/settings.py,sha256=rGRdM18Vo7xnjfZXPLRMbKeoVC_lZmzkNRPS0SQv05o,5660
-geobox/task.py,sha256=lACZ-ix3BAAU1-pNnbHC2noAtt79swrkmkCczEO7D2A,13364
+geobox/task.py,sha256=eLMgbhcYTADooWqKDPh6Jlh5S5oqxMMKoYIm0YPVZvg,13519
 geobox/tile3d.py,sha256=MHDoj2OIUf3VMQtq7ysrayh8njAPSgwgPJCm4ySEB7A,10472
 geobox/tileset.py,sha256=F_oEV0TERMc2seLcYNu-i_TF4MNSdXPUWcxBCSR8aFw,22242
 geobox/usage.py,sha256=_54xL-n-2Bg9wGpoOBKnh85WqdpMWEtqxRJVaFlVWe0,7908
-geobox/user.py,sha256=ScuuAhxUD4FcGg4fDMZjhDgJYNmV6apFDkrJNqATjvk,14486
+geobox/user.py,sha256=k80q6THt0E9-xbMzIdKWNSb9dc_KKhLneru2GLggTGM,15085
 geobox/utils.py,sha256=jKhEs6CWTSlJZDS5qw9O2KgkLnTL9GKvFyKJpp8n1fA,1116
-geobox/vectorlayer.py,sha256=xnYsJei-bpKgM_EJlRbZ-bAIHdmvfU-VZ2t-NEEJCfc,49420
+geobox/vectorlayer.py,sha256=1xjhWpvb1hFhLRei2hwU7IY5KxDKzynZMb3fbIDTMZE,51092
 geobox/version.py,sha256=0GLPhxCeEb2bAkdpPJWtXPXc1KP6kQ_TOMwLAL0ldo0,9374
-geobox/view.py,sha256=fRYlzNu4eGl6Zx9gPom47BkVE8DfWLj0bNlW2-u4TOU,37390
+geobox/view.py,sha256=sIi6Mi7NUAX5gN83cpubD3l7AcZ-1g5kG2NKHeVeW-g,37518
 geobox/workflow.py,sha256=6hKnSw4G0_ZlgmUb0g3fxT-UVsFbiYpF2FbEO5fpQv0,11606
-geobox-1.2.2.dist-info/licenses/LICENSE,sha256=AvFB7W94sJYKLDhBxLRshL3upexCOG8HQY_1JibB96w,1063
-geobox-1.2.2.dist-info/METADATA,sha256=RZiM4hs-22stMecCl19HntScQWrGeUiYN_YpyVPQUKc,2556
-geobox-1.2.2.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-geobox-1.2.2.dist-info/top_level.txt,sha256=ppXH8Bu2mlB-pLQ6lsoWEm2Gr6wZx1uzkhetsYA5ins,7
-geobox-1.2.2.dist-info/RECORD,,
+geobox-1.3.0.dist-info/licenses/LICENSE,sha256=AvFB7W94sJYKLDhBxLRshL3upexCOG8HQY_1JibB96w,1063
+geobox-1.3.0.dist-info/METADATA,sha256=UW0-KY-DuDA4blEJeWwoP05fxSMQ-yOa7AjfIs0dzzg,2556
+geobox-1.3.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+geobox-1.3.0.dist-info/top_level.txt,sha256=ppXH8Bu2mlB-pLQ6lsoWEm2Gr6wZx1uzkhetsYA5ins,7
+geobox-1.3.0.dist-info/RECORD,,