geobox 1.2.1__tar.gz → 1.2.3__tar.gz

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

@@ -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 → 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.1 → 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.1 → 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.1 → geobox-1.2.3}/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-1.2.1 → 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.1 → 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.1 → 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