geobox 1.2.1__py3-none-any.whl → 1.2.3__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):

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

@@ -2,13 +2,16 @@ from urllib.parse import urljoin
 from typing import Optional, Dict, List, Union, TYPE_CHECKING
 import os
 import mimetypes
+from geobox.exception import ValidationError
 import requests
 import sys
+from pathlib import Path
 
 from .base import Base
 from .enums import FileFormat, PublishFileType, InputGeomType, FileType
 from .utils import clean_data
 from .task import Task
+from .feature import Feature
 
 if TYPE_CHECKING:
     from . import GeoboxClient 
@@ -221,9 +224,9 @@ class File(Base):
             >>> from geobox import GeoboxClient
             >>> from geobox.file import File
             >>> client = GeoboxClient()
-            >>> files = File.get_file_by_name(client, name='test')
+            >>> files = File.get_files_by_name(client, name='test')
             or
-            >>> files = client.get_file_by_name(name='test')
+            >>> files = client.get_files_by_name(name='test')
         """
         return cls.get_files(api, q=f"name = '{name}'", user_id=user_id)
     
@@ -248,44 +251,34 @@ class File(Base):
             >>> client = GeoboxClient()
             >>> file_path = File.get_file(client, uuid="12345678-1234-5678-1234-567812345678")
         """
-        # Get the original filename from data or use uuid
-        if self.name:
-            filename = f"{self.name.split('.')[0]}" if len(self.name.split('.')) > 1 else f'{self.name}'
-        else:
-            filename = f'{self.uuid}'
-
         # If save_path is provided, check if it ends with a '/'
         if save_path and save_path.endswith('/'):
-            return f'{save_path}{filename}'
+            return f'{save_path}'
         
         if save_path and not save_path.endswith('/'):
             raise ValueError("save_path must end with a '/'")
         
-        return os.path.join(os.getcwd(), filename)
+        return os.getcwd()
     
 
-    def _get_file_ext(self, response: requests.Response) -> str:
+    def _get_file_name(self, response: requests.Response) -> str:
         """
-        Get the file extension of the response.
+        Get the file name from the response.
 
         Args:
             response (requests.Response): The response of the request.
 
         Returns:
-            str: The file extension of the response.
+            str: The file name 
         """
-        ext = ""
-        if 'Content-Disposition' in response.headers:
-            content_disposition = response.headers['Content-Disposition']
-            if 'filename=' in content_disposition:
-                filename = content_disposition.split('filename=')[-1].strip().strip('"')
-                ext = f".{filename.split('.')[-1]}"
+        if 'Content-Disposition' in response.headers and 'filename=' in response.headers['Content-Disposition']:
+            file_name = response.headers['Content-Disposition'].split('filename=')[-1].strip().strip('"')
 
-            else:
-                content_type = response.headers.get("Content-Type", "")
-                ext = mimetypes.guess_extension(content_type.split(";")[0])
+        else:
+            content_type = response.headers.get("Content-Type", "")
+            file_name = f'{self.name}.{mimetypes.guess_extension(content_type.split(";")[0])}'
 
-        return ext
+        return file_name
 
 
     def _create_progress_bar(self) -> 'tqdm':
@@ -338,20 +331,20 @@ class File(Base):
         save_path = self._get_save_path(save_path)
         os.makedirs(os.path.dirname(save_path), exist_ok=True)
         
-        with self.api.get(f"{self.endpoint}download/", stream=True) as response, \
-            open(save_path, 'wb') as f:
-            pbar = self._create_progress_bar() if progress_bar else None
-            for chunk in response.iter_content(chunk_size=8192):
-                f.write(chunk)
+        with self.api.get(f"{self.endpoint}download/", stream=True) as response:
+            file_name = self._get_file_name(response)
+            full_path = f"{save_path}/{file_name}"
+            with open(full_path, 'wb') as f:
+                pbar = self._create_progress_bar() if progress_bar else None
+                for chunk in response.iter_content(chunk_size=8192):
+                    f.write(chunk)
+                    if pbar:
+                        pbar.update(len(chunk))
+                        pbar.refresh()
                 if pbar:
-                    pbar.update(len(chunk))
-                    pbar.refresh()
-            if pbar:
-                pbar.close()
+                    pbar.close()
 
-        final_path = os.path.abspath(save_path) + self._get_file_ext(response)
-        os.rename(os.path.abspath(save_path), os.path.abspath(final_path))
-        return os.path.abspath(final_path)
+        return os.path.abspath(full_path)
 
 
     def delete(self) -> None:
@@ -378,8 +371,8 @@ class File(Base):
                     input_layer: str = None, 
                     input_dataset: str = None, 
                     user_id: int = None, 
-                    input_srid: int = None, 
-                    file_encoding: str = "utf-8", 
+                    input_srid: int = Feature.BASE_SRID, 
+                    file_encoding: str = "UTF-8", 
                     replace_domain_codes_by_values: bool = False, 
                     report_errors: bool = True, 
                     as_terrain: bool = False) -> 'Task':
@@ -393,7 +386,7 @@ class File(Base):
             input_layer (str, optional): The name of the input layer.
             input_dataset (str, optional): The name of the input dataset.
             user_id (int, optional): Specific user. privileges required.
-            input_srid (int, optional): The SRID of the layer.
+            input_srid (int, optional): The SRID of the layer. default is: 3857
             file_encoding (str, optional): The encoding of the file. default is "utf-8".
             replace_domain_codes_by_values (bool, optional): Whether to replace domain codes by values. default is False.
             report_errors (bool, optional): Whether to report errors. default is True.
@@ -404,6 +397,7 @@ class File(Base):
 
         Raises:
             ValueError: If the publish_as is not a valid PublishFileType.
+            ValidationError: if the zipped file doesn't have any layers to publish.
 
         Example:
             >>> from geobox import GeoboxClient
@@ -416,30 +410,41 @@ class File(Base):
             ...                     input_layer='layer1', 
             ...                     input_dataset='dataset1', 
             ...                     input_srid=4326, 
-            ...                     file_encoding='utf-8')
+            ...                     file_encoding='UTF-8')
         """
         if not publish_as:
-            if self.file_type.value in ['GeoJSON', 'GPKG', 'DXF', 'GPX', 'Shapefile', 'KML', 'CSV', 'FileGDB']:
+            # checks the file format or file first layer format to dynamically set the publish_as
+            if self.file_type.value in ['GeoJSON', 'GPKG', 'DXF', 'GPX', 'Shapefile', 'KML', 'CSV', 'FileGDB'] or \
+                (self.file_type.value in ['Complex'] and self.layers and \
+                    FileType(self.layers[0]['format']).value in ['GeoJSON', 'GPKG', 'DXF', 'GPX', 'Shapefile', 'KML', 'CSV', 'FileGDB']):
                 publish_as = PublishFileType.VECTOR
-            elif self.file_type.value in ['GeoTIFF']:
+
+            elif self.file_type.value in ['GeoTIFF'] or \
+                    (self.file_type.value in ['Complex'] and self.layers and \
+                        FileType(self.layers[0]['format']).value in ['GeoTIFF']):
                 publish_as = PublishFileType.RASTER
-            elif self.file_type.value in ['GLB']:
+
+            elif self.file_type.value in ['GLB'] or \
+                    (self.file_type.value in ['Complex'] and self.layers and \
+                        FileType(self.layers[0]['format']).value in ['GLB']):
                 publish_as = PublishFileType.MODEL3D
 
+            else:
+                raise ValidationError('Unknown format')
+
         data = clean_data({
             "publish_as": publish_as.value if isinstance(publish_as, PublishFileType) else publish_as,
             "layer_name": name,
-            "input_layer": input_layer,
+            "input_layer": self.layers[0]['layer'] if not input_layer and self.layers else input_layer,
             "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,
-            "input_dataset": self.name if not input_dataset else input_dataset,
+            "input_dataset": self.layers[0]['dataset'] if not input_layer and self.layers else input_dataset,
             "user_id": user_id,
             "input_srid": input_srid,
             "file_encoding": file_encoding,
             "report_errors": report_errors,
             "as_terrain": as_terrain
         })
-
         endpoint = urljoin(self.endpoint, 'publish/')
         response = self.api.post(endpoint, data, is_json=False)
         task = Task.get_task(self.api, response.get('task_id'))

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/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:

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):
@@ -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,9 +381,32 @@ 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 get_field_by_name(self, name: str) -> 'Field':
+        """
+        Get a specific field by its name.
+        
+        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.view import VectorLayerView
+            >>> client = GeoboxClient()
+            >>> view = VectorLayerView.get_view(client, uuid="12345678-1234-5678-1234-567812345678")
+            >>> field = view.get_field_by_name(name='test')
+        """      
+        return super().get_field_by_name(name)
 
 
     def add_field(self, name: str, data_type: 'FieldType', data: Dict = {}) -> 'Field':
@@ -414,7 +437,7 @@ class VectorLayerView(VectorLayer):
 
     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 +452,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 +564,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 +577,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 +596,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 +631,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 +641,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 +665,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.1.dist-info → geobox-1.2.3.dist-info}/METADATA

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

{geobox-1.2.1.dist-info → geobox-1.2.3.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=1ScREE4WFbbIbY1K1jz62PnXUHKav-GiDQmDYZwUj2c,6316
 geobox/exception.py,sha256=jvpnv0M2Ck1FpxHTL_aKYWxGvLnCQ3d9vOrMIktjw1U,1507
 geobox/feature.py,sha256=3Kbc1LjIkBt1YqRAry84BrR7qxx9BexvBB3YQ8D9mGk,18504
-geobox/field.py,sha256=2VxjeYgRwnDxHYpAsK0ASOCz8V0JmfTA3GqHDv3rfgQ,10526
-geobox/file.py,sha256=NqN9EoSGMiTev5vo_1QKciofcyoXonLoZz7B8hH_igk,19352
+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/utils.py,sha256=jKhEs6CWTSlJZDS5qw9O2KgkLnTL9GKvFyKJpp8n1fA,1116
-geobox/vectorlayer.py,sha256=xnYsJei-bpKgM_EJlRbZ-bAIHdmvfU-VZ2t-NEEJCfc,49420
+geobox/vectorlayer.py,sha256=_EV-Ht7B9v_tS8fOYXzsbrHASopoAoz5RNdvisW4BWc,50938
 geobox/version.py,sha256=0GLPhxCeEb2bAkdpPJWtXPXc1KP6kQ_TOMwLAL0ldo0,9374
-geobox/view.py,sha256=fRYlzNu4eGl6Zx9gPom47BkVE8DfWLj0bNlW2-u4TOU,37390
+geobox/view.py,sha256=or4n8SQ8tVu8I4BNLqxJTAUXL2ZrhvJ1xDdslhu60_A,38541
 geobox/workflow.py,sha256=6hKnSw4G0_ZlgmUb0g3fxT-UVsFbiYpF2FbEO5fpQv0,11606
-geobox-1.2.1.dist-info/licenses/LICENSE,sha256=AvFB7W94sJYKLDhBxLRshL3upexCOG8HQY_1JibB96w,1063
-geobox-1.2.1.dist-info/METADATA,sha256=toqzfxiUTgzmI9Vn5BAIN6v1D_4HGsT-naLcNP4F-28,2556
-geobox-1.2.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-geobox-1.2.1.dist-info/top_level.txt,sha256=ppXH8Bu2mlB-pLQ6lsoWEm2Gr6wZx1uzkhetsYA5ins,7
-geobox-1.2.1.dist-info/RECORD,,
+geobox-1.2.3.dist-info/licenses/LICENSE,sha256=AvFB7W94sJYKLDhBxLRshL3upexCOG8HQY_1JibB96w,1063
+geobox-1.2.3.dist-info/METADATA,sha256=7u1F3M5PmC_7ubwqIj1NiGAw3-JQ7SgcT7jQEizagxk,2556
+geobox-1.2.3.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+geobox-1.2.3.dist-info/top_level.txt,sha256=ppXH8Bu2mlB-pLQ6lsoWEm2Gr6wZx1uzkhetsYA5ins,7
+geobox-1.2.3.dist-info/RECORD,,