geobox 1.3.4__tar.gz → 1.4.0__tar.gz

{geobox-1.3.4 → geobox-1.4.0}/PKG-INFO

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

{geobox-1.3.4 → geobox-1.4.0}/geobox/api.py

@@ -20,6 +20,7 @@ from .map import Map
 from .user import User, UserRole, UserStatus, Session
 from .query import Query
 from .workflow import Workflow
+from .layout import Layout
 from .version import VectorLayerVersion
 from .tile3d import Tile3d
 from .settings import SystemSettings
@@ -1535,7 +1536,7 @@ class GeoboxClient:
         Example:
             >>> from geobox import GeoboxClient
             >>> client = GeoboxClient()
-            >>> workflows = client.get_workflow(q="name LIKE '%My workflow%'")
+            >>> workflows = client.get_workflows(q="name LIKE '%My workflow%'")
         """
         return Workflow.get_workflows(self, **kwargs)
     
@@ -1681,6 +1682,105 @@ class GeoboxClient:
         return VectorLayerVersion.get_version_by_name(self, name, user_id)
     
 
+    def get_layouts(self, **kwargs) -> Union[List['Layout'], int]:
+        """
+        Get list of layouts with optional filtering and pagination.
+
+        Keyword Args:
+            q (str): query filter based on OGC CQL standard. e.g. "field1 LIKE '%GIS%' AND created_at > '2021-01-01'"
+            search (str): search term for keyword-based searching among search_fields or all textual fields if search_fields does not have value. NOTE: if q param is defined this param will be ignored.
+            search_fields (str): comma separated list of fields for searching.
+            order_by (str): comma separated list of fields for sorting results [field1 A|D, field2 A|D, …]. e.g. name A, type D. NOTE: "A" denotes ascending order and "D" denotes descending order.
+            return_count (bool): Whether to return total count. default is False.
+            skip (int): Number of items to skip. default is 0.
+            limit (int): Number of items to return. default is 10.
+            user_id (int): Specific user. privileges required.
+            shared (bool): Whether to return shared layouts. default is False.
+
+        Returns:
+            List[Layout] | int: A list of layout instances or the total number of layouts.
+
+        Example:
+            >>> from geobox import GeoboxClient
+            >>> client = GeoboxClient()
+            >>> layouts = client.get_layouts(q="name LIKE '%My layout%'")
+        """
+        return Layout.get_layouts(self, **kwargs)
+    
+
+    def create_layout(self,
+                    name: str, 
+                    display_name: str = None, 
+                    description: str = None, 
+                    settings: Dict = {}, 
+                    thumbnail: str = None, 
+                    user_id: int = None) -> 'Layout':
+        """
+        Create a new layout.
+
+        Args:
+            name (str): The name of the layout.
+            display_name (str): The display name of the layout.
+            description (str): The description of the layout.
+            settings (Dict): The settings of the layout.
+            thumbnail (str): The thumbnail of the layout.
+            user_id (int): Specific user. privileges layout.
+
+        Returns:
+            Layout: The newly created layout instance.
+
+        Raises:
+            ValidationError: If the layout data is invalid.
+
+        Example:
+            >>> from geobox import GeoboxClient
+            >>> client = GeoboxClient()
+            >>> layout = client.create_layout(name="my_layout")
+        """
+        return Layout.create_layout(self, name, display_name, description, settings, thumbnail, user_id)
+
+
+    def get_layout(self, uuid: str, user_id: int = None) -> 'Layout':
+        """
+        Get a layout by its UUID.
+
+        Args:
+            uuid (str): The UUID of the layout to get.
+            user_id (int): Specific user. privileges required.
+
+        Returns:
+            Layout: The layout object.
+
+        Raises:
+            NotFoundError: If the layout with the specified UUID is not found.
+
+        Example:
+            >>> from geobox import GeoboxClient
+            >>> client = GeoboxClient()
+            >>> layout = client.get_layout(uuid="12345678-1234-5678-1234-567812345678")
+        """
+        return Layout.get_layout(self, uuid, user_id)
+
+
+    def get_layout_by_name(self, name: str, user_id: int = None) -> Union['Layout', None]:
+        """
+        Get a layout by name
+
+        Args:
+            name (str): the name of the layout to get
+            user_id (int, optional): specific user. privileges required.
+
+        Returns:
+            Layout | None: returns the layout if a layout matches the given name, else None
+
+        Example:
+            >>> from geobox import GeoboxClient
+            >>> client = GeoboxClient()
+            >>> layout = client.get_layout_by_name(name='test')
+        """
+        return Layout.get_layout_by_name(self, name, user_id)
+
+
     def get_3dtiles(self, **kwargs) -> Union[List['Tile3d'], int]:
         """
         Get list of 3D Tiles with optional filtering and pagination.
@@ -2016,6 +2116,25 @@ class GeoboxClient:
         return Plan.get_plan(self, plan_id)
     
 
+    def get_plan_by_name(self, name: str) -> Union['Plan', None]:
+        """
+        Get a plan by name
+
+        Args:
+            api (GeoboxClient): The GeoboxClient instance for making requests.
+            name (str): the name of the plan to get
+
+        Returns:
+            Plan | None: returns the plan if a plan matches the given name, else None
+
+        Example:
+            >>> from geobox import GeoboxClient
+            >>> client = GeoboxClient()
+            >>> plan = client.get_plan_by_name(name='test')
+        """
+        return Plan.get_plan_by_name(self, name)
+    
+
     def get_dashboards(self, **kwargs) -> Union[List['Dashboard'], int]:
         """
         Get list of Dashboards

{geobox-1.3.4 → geobox-1.4.0}/geobox/apikey.py

@@ -176,11 +176,14 @@ class ApiKey(Base):
             >>> apikey = ApiKey.get_apikey(client, key_id=1)
             >>> apikey.update(name="updated_name")
         """
-        data = {
+        data = clean_data({
             "name": name,
             "user_id": user_id
-        }
-        return super()._update(self.endpoint, data)
+        })
+
+        response = self.api.put(self.endpoint, data, is_json=False)
+        self._update_properties(response)
+        return response
 
 
     def delete(self) -> None:

{geobox-1.3.4 → geobox-1.4.0}/geobox/enums.py

@@ -19,6 +19,7 @@ class PublishFileType(Enum):
     VECTOR = 'vector'
     RASTER = 'raster'
     MODEL3D = 'model3d'
+    Tiles3D = 'tiles3d'
 
 class FileType(Enum):
     Compressed = 'Compressed'
@@ -36,6 +37,7 @@ class FileType(Enum):
     FileGDB = 'FileGDB'
     GeoTIFF = 'GeoTIFF'
     GeoJSON = 'GeoJSON'
+    ThreedTiles = 'ThreedTiles'
 
 class FileFormat(Enum):
     # Spatial Data Formats

{geobox-1.3.4 → geobox-1.4.0}/geobox/file.py

@@ -429,6 +429,9 @@ class File(Base):
                         FileType(self.layers[0]['format']).value in ['GLB']):
                 publish_as = PublishFileType.MODEL3D
 
+            elif self.file_type.value in ['ThreedTiles']:
+                publish_as = PublishFileType.Tiles3D
+
             else:
                 raise ValidationError('Unknown format')
 

geobox-1.4.0/geobox/layout.py

@@ -0,0 +1,314 @@
+from typing import List, Dict, Optional, TYPE_CHECKING, Union
+
+from .base import Base
+
+if TYPE_CHECKING:
+    from . import GeoboxClient
+    from .user import User
+
+class Layout(Base):
+
+    BASE_ENDPOINT = 'layouts/'
+
+    def __init__(self, 
+                 api: 'GeoboxClient', 
+                 uuid: str,
+                 data: Optional[Dict] = {}):
+        """
+        Initialize a layout instance.
+
+        Args:
+            api (GeoboxClient): The GeoboxClient instance for making requests.
+            uuid (str): The unique identifier for the layout.
+            data (Dict): The data of the layout.
+        """
+        super().__init__(api, uuid=uuid, data=data)
+
+
+    @classmethod
+    def get_layouts(cls, api: 'GeoboxClient', **kwargs) -> Union[List['Layout'], int]:
+        """
+        Get list of layouts with optional filtering and pagination.
+
+        Args:
+            api (GeoboxClient): The GeoboxClient instance for making requests.
+
+        Keyword Args:
+            q (str): query filter based on OGC CQL standard. e.g. "field1 LIKE '%GIS%' AND created_at > '2021-01-01'"
+            search (str): search term for keyword-based searching among search_fields or all textual fields if search_fields does not have value. NOTE: if q param is defined this param will be ignored.
+            search_fields (str): comma separated list of fields for searching.
+            order_by (str): comma separated list of fields for sorting results [field1 A|D, field2 A|D, …]. e.g. name A, type D. NOTE: "A" denotes ascending order and "D" denotes descending order.
+            return_count (bool): Whether to return total count. default is False.
+            skip (int): Number of items to skip. default is 0.
+            limit (int): Number of items to return. default is 10.
+            user_id (int): Specific user. privileges required.
+            shared (bool): Whether to return shared layouts. default is False.
+
+        Returns:
+            List[Layout] | int: A list of layout instances or the total number of layouts.
+
+        Example:
+            >>> from geobox import GeoboxClient
+            >>> from geobox.layout import Layout
+            >>> client = GeoboxClient()
+            >>> layouts = Layout.get_layout(client, q="name LIKE '%My layout%'")
+            or
+            >>> layouts = client.get_layout(q="name LIKE '%My layout%'")
+        """
+        params = {
+           'f': 'json',
+           'q': kwargs.get('q'),
+           'search': kwargs.get('search'),
+           'search_fields': kwargs.get('search_fields'),
+           'order_by': kwargs.get('order_by'),
+           'return_count': kwargs.get('return_count', False),
+           'skip': kwargs.get('skip', 0),
+           'limit': kwargs.get('limit', 10),
+           'user_id': kwargs.get('user_id'),
+           'shared': kwargs.get('shared', False)
+        }
+        return super()._get_list(api, cls.BASE_ENDPOINT, params, factory_func=lambda api, item: Layout(api, item['uuid'], item))
+    
+
+    @classmethod
+    def create_layout(cls, 
+                     api: 'GeoboxClient', 
+                     name: str, 
+                     display_name: str = None, 
+                     description: str = None, 
+                     settings: Dict = {}, 
+                     thumbnail: str = None, 
+                     user_id: int = None) -> 'Layout':
+        """
+        Create a new layout.
+
+        Args:
+            api (GeoboxClient): The GeoboxClient instance for making requests.
+            name (str): The name of the Layout.
+            display_name (str): The display name of the layout.
+            description (str): The description of the layout.
+            settings (Dict): The settings of the layout.
+            thumbnail (str): The thumbnail of the layout.
+            user_id (int): Specific user. privileges layout.
+
+        Returns:
+            Layout: The newly created layout instance.
+
+        Raises:
+            ValidationError: If the layout data is invalid.
+
+        Example:
+            >>> from geobox import GeoboxClient
+            >>> from geobox.layout import Layout
+            >>> client = GeoboxClient()
+            >>> layout = Layout.create_layout(client, name="my_layout")
+            or
+            >>> layout = client.create_layout(name="my_layout")
+        """
+        data = {
+            "name": name,
+            "display_name": display_name,
+            "description": description,
+            "settings": settings,
+            "thumbnail": thumbnail,
+            "user_id": user_id,
+        }
+        return super()._create(api, cls.BASE_ENDPOINT, data, factory_func=lambda api, item: Layout(api, item['uuid'], item))
+
+    
+    @classmethod
+    def get_layout(cls, api: 'GeoboxClient', uuid: str, user_id: int = None) -> 'Layout':
+        """
+        Get a layout by its UUID.
+
+        Args:
+            api (GeoboxClient): The GeoboxClient instance for making requests.
+            uuid (str): The UUID of the layout to get.
+            user_id (int): Specific user. privileges required.
+
+        Returns:
+            Layout: The layout object.
+
+        Raises:
+            NotFoundError: If the layout with the specified UUID is not found.
+
+        Example:
+            >>> from geobox import GeoboxClient
+            >>> from geobox.layout import Layout
+            >>> client = GeoboxClient()
+            >>> layout = Layout.get_layout(client, uuid="12345678-1234-5678-1234-567812345678")
+            or
+            >>> layout = client.get_layout(uuid="12345678-1234-5678-1234-567812345678")
+        """
+        params = {
+            'f': 'json',
+            'user_id': user_id,
+        }
+        return super()._get_detail(api, cls.BASE_ENDPOINT, uuid, params, factory_func=lambda api, item: Layout(api, item['uuid'], item))
+
+
+    @classmethod
+    def get_layout_by_name(cls, api: 'GeoboxClient', name: str, user_id: int = None) -> Union['Layout', None]:
+        """
+        Get a layout by name
+
+        Args:
+            api (GeoboxClient): The GeoboxClient instance for making requests.
+            name (str): the name of the layout to get
+            user_id (int, optional): specific user. privileges required.
+
+        Returns:
+            Layout | None: returns the layout if a layout matches the given name, else None
+
+        Example:
+            >>> from geobox import GeoboxClient
+            >>> from geobox.layout import Layout
+            >>> client = GeoboxClient()
+            >>> layout = Layout.get_layout_by_name(client, name='test')
+            or
+            >>> layout = client.get_layout_by_name(name='test')
+        """
+        layouts = cls.get_layouts(api, q=f"name = '{name}'", user_id=user_id)
+        if layouts and layouts[0].name == name:
+            return layouts[0]
+        else:
+            return None
+
+
+    def update(self, **kwargs) -> Dict:
+        """
+        Update the layout.
+
+        Keyword Args:
+            name (str): The name of the layout.
+            display_name (str): The display name of the layout.
+            description (str): The description of the layout.
+            settings (Dict): The settings of the layout.
+            thumbnail (str): The thumbnail of the layout.
+
+        Returns:
+            Dict: The updated layout data.
+
+        Raises:
+            ValidationError: If the layout data is invalid.
+
+        Example:
+            >>> from geobox import GeoboxClient
+            >>> from geobox.layout import Layout
+            >>> client = GeoboxClient()
+            >>> layout = Layout.get_layout(client, uuid="12345678-1234-5678-1234-567812345678")
+            >>> layout.update_layout(display_name="New Display Name")
+        """
+        data = {
+            "name": kwargs.get('name'),
+            "display_name": kwargs.get('display_name'),   
+            "description": kwargs.get('description'),
+            "settings": kwargs.get('settings'),
+            "thumbnail": kwargs.get('thumbnail')
+        }
+        return super()._update(self.endpoint, data)
+    
+
+    def delete(self) -> None:
+        """
+        Delete the Layout.
+
+        Returns:
+            None
+
+        Example:
+            >>> from geobox import GeoboxClient
+            >>> from geobox.layout import Layout
+            >>> client = GeoboxClient()
+            >>> layout = Layout.get_layout(client, uuid="12345678-1234-5678-1234-567812345678")
+            >>> layout.delete()
+        """
+        super().delete(self.endpoint)
+
+
+    @property
+    def thumbnail(self) -> str:
+        """
+        Get the thumbnail URL of the Layout.
+
+        Returns:
+            str: The thumbnail of the Layout.
+
+        Example:
+            >>> from geobox import GeoboxClient
+            >>> from geobox.layout import Layout
+            >>> client = GeoboxClient()
+            >>> layout = Layout.get_layout(client, uuid="12345678-1234-5678-1234-567812345678")
+            >>> layout.thumbnail
+            'https://example.com/thumbnail.png'
+        """
+        return super().thumbnail()
+    
+
+    def share(self, users: List['User']) -> None:
+        """
+        Shares the layout with specified users.
+
+        Args:
+            users (List[User]): The list of user objects to share the layout with.
+
+        Returns:
+            None
+
+        Example:
+            >>> from geobox import GeoboxClient             
+            >>> from geobox.layout import Layout
+            >>> client = GeoboxClient()
+            >>> layout = Layout.get_layout(client, uuid="12345678-1234-5678-1234-567812345678")
+            >>> users = client.search_users(search='John')
+            >>> layout.share(users=users)
+        """
+        super()._share(self.endpoint, users)
+    
+
+    def unshare(self, users: List['User']) -> None:
+        """
+        Unshares the layout with specified users.
+
+        Args:
+            users (List[User]): The list of user objects to unshare the layout with.
+
+        Returns:
+            None
+
+        Example:
+            >>> from geobox import GeoboxClient             
+            >>> from geobox.layout import Layout
+            >>> client = GeoboxClient()
+            >>> layout = Layout.get_layout(client, uuid="12345678-1234-5678-1234-567812345678")
+            >>> users = client.search_users(search='John')
+            >>> layout.unshare(users=users)
+        """
+        super()._unshare(self.endpoint, users)
+
+
+    def get_shared_users(self, search: str = None, skip: int = 0, limit: int = 10) -> List['User']:
+        """
+        Retrieves the list of users the layout is shared with.
+
+        Args:
+            search (str, optional): The search query.
+            skip (int, optional): The number of users to skip.
+            limit (int, optional): The maximum number of users to retrieve.
+
+        Returns:
+            List[User]: The list of shared users.
+
+        Example:
+            >>> from geobox import GeoboxClient
+            >>> from geobox.layout import Layout
+            >>> client = GeoboxClient()
+            >>> layout = Layout.get_layout(client, uuid="12345678-1234-5678-1234-567812345678")
+            >>> layout.get_shared_users(search='John', skip=0, limit=10)
+        """
+        params = {
+            'search': search,
+            'skip': skip,
+            'limit': limit
+        }
+        return super()._get_shared_users(self.endpoint, params)

{geobox-1.3.4 → geobox-1.4.0}/geobox/map.py

@@ -859,4 +859,43 @@ class Map(Base):
             >>> map.image_tile_url()
             >>> map.image_tile_url(x=1, y=2, z=3, format='.pbf')
         """
-        return f"{self.BASE_ENDPOINT}{self.endpoint}{z}/{x}/{y}{format}"
+        endpoint = f"{self.api.base_url}{self.endpoint}tiles/{z}/{x}/{y}{format}"
+
+        if not self.api.access_token and self.api.apikey:
+            endpoint = f'{endpoint}?apikey={self.api.apikey}'
+
+        return endpoint
+    
+
+    def export_map_to_image(self, bbox: List, width: int, height: int) -> 'Task':
+        """
+        Export the map to image
+
+        Args:
+            bbox (List): e.g. [50.275, 35.1195, 51.4459, 36.0416]
+            width (int): minimum: 10, maximum: 10000
+            height (int): minimum: 10, maximum: 10000
+
+        Returns:
+            Task: the task object
+
+        Example:
+            >>> from geobox import GeoboxClient
+            >>> from geobox.map import Map
+            >>> client = GeoboxClient()
+            >>> map = Map.get_map(client, uuid="12345678-1234-5678-1234-567812345678")
+            >>> task = map.export_map_to_image(bbox=[50.275, 35.1195, 51.4459, 36.0416],
+            ...                                 width=1024,
+            ...                                 height=1024)
+        """
+        data = clean_data({
+            'uuid': self.uuid,
+            'bbox': bbox,
+            'width': width,
+            'height': height
+        })
+        query_string = urlencode(data)
+        endpoint = urljoin(self.endpoint, 'export/')
+        endpoint = f"{endpoint}?{query_string}"
+        response = self.api.post(endpoint)
+        return self.api.get_task(response['task_id'])

{geobox-1.3.4 → geobox-1.4.0}/geobox/model3d.py

@@ -152,6 +152,7 @@ class Model(Base):
 
         Keyword Args:
             name (str): The new name for the model.
+            display_name (str): The new display name.
             description (str): The new description for the model.
             settings (Dict): The new settings for the model.
             thumbnail (str): The new thumbnail for the model.
@@ -190,6 +191,7 @@ class Model(Base):
         """
         data = {
             'name': kwargs.get('name'),
+            'display_name': kwargs.get('display_name'),
             'description': kwargs.get('description'),
             'settings': kwargs.get('settings'),
             'thumbnail': kwargs.get('thumbnail')

{geobox-1.3.4 → geobox-1.4.0}/geobox/plan.py

@@ -191,6 +191,33 @@ class Plan(Base):
             'f': 'json'
         }
         return super()._get_detail(api, cls.BASE_ENDPOINT, plan_id, params, factory_func=lambda api, item: Plan(api, item['id'], item))
+    
+
+    @classmethod
+    def get_plan_by_name(cls, api: 'GeoboxClient', name: str) -> Union['Plan', None]:
+        """
+        Get a plan by name
+
+        Args:
+            api (GeoboxClient): The GeoboxClient instance for making requests.
+            name (str): the name of the plan to get
+
+        Returns:
+            Plan | None: returns the plan if a plan matches the given name, else None
+
+        Example:
+            >>> from geobox import GeoboxClient
+            >>> from geobox.plan import Plan
+            >>> client = GeoboxClient()
+            >>> plan = Workflow.get_plan_by_name(client, name='test')
+            or
+            >>> plan = client.get_plan_by_name(name='test')
+        """
+        plans = cls.get_plans(api, q=f"name = '{name}'")
+        if plans and plans[0].name == name:
+            return plans[0]
+        else:
+            return None
 
 
     def update(self, **kwargs) -> Dict:

{geobox-1.3.4 → geobox-1.4.0}/geobox/raster.py

@@ -513,6 +513,10 @@ class Raster(Base):
         endpoint = f'{self.api.base_url}{self.endpoint}render/{z}/{x}/{y}.png'
         if query_string:
             endpoint = f'{endpoint}?{query_string}'
+
+        if not self.api.access_token and self.api.apikey:
+            endpoint = join_url_params(endpoint, {"apikey": self.api.apikey})
+            
         return endpoint
     
 

{geobox-1.3.4 → geobox-1.4.0}/geobox/task.py

@@ -11,6 +11,7 @@ if TYPE_CHECKING:
     from .raster import Raster
     from .model3d import Model
     from .file import File
+    from .tile3d import Tile3d
 
 class Task(Base):
     """
@@ -46,12 +47,12 @@ class Task(Base):
 
 
     @property
-    def output_asset(self) -> Union['VectorLayer', 'Raster', 'Model', 'File', None]:
+    def output_asset(self) -> Union['VectorLayer', 'Raster', 'Model', 'File', 'Tile3d', None]:
         """
         output asset property
 
         Returns:
-            VectorLayer | Raster | Model | None: if task type is publish, it returns the published layer
+            VectorLayer | Raster | Model | Tile3d | None: if task type is publish, it returns the published layer
 
         Example:
             >>> from geobox import GeoboxClient
@@ -71,6 +72,9 @@ class Task(Base):
 
         elif self.data.get('result', {}).get('file_uuid'):
             return self.api.get_file(uuid=self.data['result']['file_uuid'])
+        
+        elif self.data.get('result', {}).get('3dtiles_uuid'):
+            return self.api.get_3dtile(uuid=self.data['result']['3dtiles_uuid'])
 
         else:
             return None

{geobox-1.3.4 → geobox-1.4.0}/geobox/tile3d.py

@@ -1,4 +1,5 @@
 from typing import List, Dict, Optional, TYPE_CHECKING, Union
+from urllib.parse import urljoin
 
 from .base import Base
 
@@ -291,4 +292,22 @@ class Tile3d(Base):
             'skip': skip,
             'limit': limit
         }
-        return super()._get_shared_users(self.endpoint, params)
+        return super()._get_shared_users(self.endpoint, params)
+    
+
+    def get_tileset_json(self) -> Dict:
+        """
+        Get Tileset JSON of a 3D Tiles.
+        
+        Returns:
+            Dict: The tileset JSON configuration.
+
+        Example:
+            >>> from geobox import GeoboxClient
+            >>> from geobox.tile3d import Tile3d
+            >>> client = GeoboxClient()
+            >>> tile = Tile3d.get_3dtile(api=client, uuid="12345678-1234-5678-1234-567812345678")
+            >>> tile_json = tile.get_tileset_json()
+        """
+        endpoint = urljoin(self.endpoint, 'tileset.json') 
+        return self.api.get(endpoint)

{geobox-1.3.4 → geobox-1.4.0}/geobox/workflow.py

@@ -51,9 +51,9 @@ class Workflow(Base):
             >>> from geobox import GeoboxClient
             >>> from geobox.workflow import Workflow
             >>> client = GeoboxClient()
-            >>> workflows = Workflow.get_workflow(client, q="name LIKE '%My workflow%'")
+            >>> workflows = Workflow.get_workflows(client, q="name LIKE '%My workflow%'")
             or
-            >>> workflows = client.get_workflow(q="name LIKE '%My workflow%'")
+            >>> workflows = client.get_workflows(q="name LIKE '%My workflow%'")
         """
         params = {
            'f': 'json',

{geobox-1.3.4 → geobox-1.4.0}/geobox.egg-info/PKG-INFO

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

{geobox-1.3.4 → geobox-1.4.0}/geobox.egg-info/SOURCES.txt

@@ -13,6 +13,7 @@ geobox/exception.py
 geobox/feature.py
 geobox/field.py
 geobox/file.py
+geobox/layout.py
 geobox/log.py
 geobox/map.py
 geobox/model3d.py
@@ -46,6 +47,7 @@ tests/test_dashboard.py
 tests/test_feature.py
 tests/test_field.py
 tests/test_file.py
+tests/test_layout.py
 tests/test_log.py
 tests/test_map.py
 tests/test_model3d.py

{geobox-1.3.4 → geobox-1.4.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "geobox"
-version = "1.3.4"
+version = "1.4.0"
 description = "SDK for Geobox's APIs"
 authors = [
   {name = "Hamid Heydari", email = "heydari.h62@gmail.com"}

{geobox-1.3.4 → geobox-1.4.0}/tests/test_api.py

@@ -1437,6 +1437,67 @@ def test_get_version_by_name(mock_version_data):
         assert version.data == mock_version_data
 
 
+def test_get_layouts(mock_layout_data):
+    with patch('geobox.api.GeoboxClient.get_access_token') as mock_get_token, \
+         patch('geobox.api.GeoboxClient.get') as mock_get:
+        
+        mock_get_token.return_value = 'test_token'
+        mock_get.return_value = [mock_layout_data, mock_layout_data]
+        
+        client = GeoboxClient(username='testuser', password='testpassword')
+        layouts = client.get_layouts()
+        
+        assert len(layouts) == 2
+        assert isinstance(layouts[0], Layout)
+        assert layouts[0].data == mock_layout_data
+
+
+def test_create_layout(mock_layout_data):
+    with patch('geobox.api.GeoboxClient.get_access_token') as mock_get_token, \
+         patch('geobox.api.GeoboxClient.post') as mock_get:
+        
+        mock_get_token.return_value = 'test_token'
+        mock_get.return_value = mock_layout_data
+        
+        client = GeoboxClient(username='testuser', password='testpassword')
+        layout = client.create_layout(name=mock_layout_data['name'],
+                                        display_name=mock_layout_data['display_name'],
+                                        description=mock_layout_data['description'],
+                                        settings=mock_layout_data['settings'],
+                                        thumbnail=mock_layout_data.get('thumbnail'))
+        
+        assert isinstance(layout, Layout)
+        assert layout.data == mock_layout_data
+
+
+def test_get_layout(mock_layout_data):
+    with patch('geobox.api.GeoboxClient.get_access_token') as mock_get_token, \
+         patch('geobox.api.GeoboxClient.get') as mock_get:
+        
+        mock_get_token.return_value = 'test_token'
+        mock_get.return_value = mock_layout_data
+        
+        client = GeoboxClient(username='testuser', password='testpassword')
+        layout = client.get_layout(uuid=mock_layout_data['uuid'])
+        
+        assert isinstance(layout, Layout)
+        assert layout.data == mock_layout_data
+
+
+def test_get_layout_by_name(mock_layout_data):
+    with patch('geobox.api.GeoboxClient.get_access_token') as mock_get_token, \
+         patch('geobox.api.GeoboxClient.get') as mock_get:
+        
+        mock_get_token.return_value = 'test_token'
+        mock_get.return_value = [mock_layout_data]
+        
+        client = GeoboxClient(username='testuser', password='testpassword')
+        layout = client.get_layout_by_name(name=mock_layout_data['name'])
+        
+        assert isinstance(layout, Layout)
+        assert layout.data == mock_layout_data
+
+
 def test_get_3dtiles(mock_tile3d_data):
     with patch('geobox.api.GeoboxClient.get_access_token') as mock_get_token, \
          patch('geobox.api.GeoboxClient.get') as mock_get:
@@ -1626,6 +1687,20 @@ def test_get_plan(mock_plan_data):
         assert plan.data == mock_plan_data
 
 
+def test_get_plan_by_name(mock_plan_data):
+    with patch('geobox.api.GeoboxClient.get_access_token') as mock_get_token, \
+         patch('geobox.api.GeoboxClient.get') as mock_get:
+        
+        mock_get_token.return_value = 'test_token'
+        mock_get.return_value = [mock_plan_data]
+        
+        client = GeoboxClient(username='testuser', password='testpassword')
+        plan = client.get_plan_by_name(name=mock_plan_data['name'])
+        
+        assert isinstance(plan, Plan)
+        assert plan.data == mock_plan_data
+
+
 def test_get_dashboards(mock_dashboard_data):
     with patch('geobox.api.GeoboxClient.get_access_token') as mock_get_token, \
          patch('geobox.api.GeoboxClient.get') as mock_get:

{geobox-1.3.4 → geobox-1.4.0}/tests/test_apikey.py

@@ -63,7 +63,7 @@ def test_update(api, mock_apikey_data):
 
     api.put.return_value = updated_data
     apikey.update(name='updated_name')
-    api.put.assert_called_once_with(apikey.endpoint, {'name': 'updated_name'})
+    api.put.assert_called_once_with(apikey.endpoint, {'name': 'updated_name'}, is_json=False)
 
 
 def test_delete(api, mock_apikey_data):

geobox-1.4.0/tests/test_layout.py

@@ -0,0 +1,136 @@
+import pytest
+from unittest.mock import patch
+
+from geobox.layout import Layout
+from geobox.user import User
+
+def test_init(api, mock_layout_data):
+    layout = Layout(api, mock_layout_data['uuid'], mock_layout_data)
+    assert layout.name == mock_layout_data['name']
+    assert layout.uuid == mock_layout_data['uuid']
+    assert layout.data == mock_layout_data
+    assert layout.endpoint == f'{Layout.BASE_ENDPOINT}{layout.uuid}/'
+
+
+def test_get_layouts(api, mock_layout_data):
+    api.get.return_value = [mock_layout_data, mock_layout_data]
+    layouts = Layout.get_layouts(api)
+    api.get.assert_called_once_with(f'{Layout.BASE_ENDPOINT}?f=json&return_count=False&skip=0&limit=10&shared=False')
+    assert len(layouts) == 2
+    assert type(layouts[0]) == Layout
+    assert layouts[0].data == mock_layout_data
+
+
+def test_create_layout(api, mock_layout_data):
+    api.post.return_value = mock_layout_data
+    layout = Layout.create_layout(api,
+                                        name=mock_layout_data['name'],
+                                        display_name=mock_layout_data['display_name'],
+                                        description=mock_layout_data['description'],
+                                        settings=mock_layout_data['settings'],
+                                        thumbnail=mock_layout_data.get('thumbnail'))
+    api.post.assert_called_once_with(Layout.BASE_ENDPOINT, {'name': 'test', 'settings': {}})
+    assert type(layout) == Layout
+    assert layout.uuid == mock_layout_data['uuid']
+    assert layout.data == mock_layout_data
+
+
+def test_get_layout(api, mock_layout_data):
+    api.get.return_value = mock_layout_data
+    layout = Layout.get_layout(api, uuid=mock_layout_data['uuid'])
+    api.get.assert_called_once_with(f"{Layout.BASE_ENDPOINT}{mock_layout_data['uuid']}/?f=json")
+    assert type(layout) == Layout
+    assert layout.uuid == mock_layout_data['uuid']
+    assert layout.data == mock_layout_data
+
+
+def test_get_layout_by_name(api, mock_layout_data):
+    api.get.return_value = [mock_layout_data]
+    layout = Layout.get_layout_by_name(api, name=mock_layout_data['name'])
+    api.get.assert_called_once_with(f"{Layout.BASE_ENDPOINT}?f=json&q=name+%3D+%27test%27&return_count=False&skip=0&limit=10&shared=False")
+    assert type(layout) == Layout
+    assert layout.uuid == mock_layout_data['uuid']
+    assert layout.data == mock_layout_data
+    # not found
+    layout = Layout.get_layout_by_name(api, name='not_found')
+    assert layout == None
+
+
+def test_update(api, mock_layout_data):
+    layout = Layout(api, mock_layout_data['uuid'], mock_layout_data)
+    updated_data = {**mock_layout_data,
+                    'settings': {'settings': 'value'},
+                    'thumbnail': 'thumbnail-url'}
+
+    api.put.return_value = updated_data
+    layout.update(settings={'settings': 'value'}, thumbnail='thumbnail-url')
+    api.put.assert_called_once_with(layout.endpoint, {'settings': {'settings': 'value'}, 'thumbnail': 'thumbnail-url'})
+
+
+def test_delete(api, mock_layout_data):
+    layout = Layout(api, mock_layout_data['uuid'], mock_layout_data)
+    endpoint = layout.endpoint
+    layout.delete()
+    api.delete.assert_called_once_with(endpoint)
+    assert layout.uuid is None
+    assert layout.endpoint is None
+
+
+def test_thumbnail(api, mock_layout_data):
+    layout = Layout(api, mock_layout_data['uuid'], mock_layout_data)
+    thumbnail_url = layout.thumbnail
+    assert thumbnail_url == f"{api.base_url}{layout.endpoint}thumbnail.png"
+
+
+def test_share(api, mock_layout_data, mock_user_data):
+    """Test file sharing."""
+    with patch.object(api, 'post'):
+        layout = Layout(api, uuid=mock_layout_data['uuid'], data=mock_layout_data)
+        users = [
+            User(api, user_id=mock_user_data['1']['id'], data=mock_user_data['1']),
+            User(api, user_id=mock_user_data['2']['id'], data=mock_user_data['2'])
+        ]
+        layout.share(users=users)
+        api.post.assert_called_once_with(
+            f'{layout.endpoint}share/',
+            {'user_ids': [1, 2]}, is_json=False
+        )
+
+
+def test_unshare(api, mock_layout_data, mock_user_data):
+    """Test file unsharing."""
+    with patch.object(api, 'post'):
+        layout = Layout(api, uuid=mock_layout_data['uuid'], data=mock_layout_data)
+        users = [
+            User(api, user_id=mock_user_data['1']['id'], data=mock_user_data['1']),
+            User(api, user_id=mock_user_data['2']['id'], data=mock_user_data['2'])
+        ]
+        layout.unshare(users=users)
+        
+        # Verify the API call
+        api.post.assert_called_once_with(
+            f'{layout.endpoint}unshare/',
+            {'user_ids': [1, 2]}, is_json=False
+        )
+
+
+def test_get_shared_users(api, mock_layout_data, mock_user_data):
+    """Test getting shared users."""
+    mock_response = [
+        mock_user_data['1'],
+        mock_user_data['2']
+    ]
+    
+    with patch.object(api, 'get', return_value=mock_response):
+        layout = Layout(api, uuid=mock_layout_data['uuid'], data=mock_layout_data)
+        result = layout.get_shared_users(search='user', limit=2)
+
+        api.get.assert_called_once_with(
+            f'{layout.endpoint}shared-with-users/?search=user&skip=0&limit=2'
+        )
+
+        assert len(result) == 2
+        assert result[0].first_name == 'test 1'
+        assert result[0].last_name == 'test 1'
+        assert result[1].first_name == 'test 2'
+        assert result[1].last_name == 'test 2'

{geobox-1.3.4 → geobox-1.4.0}/tests/test_map.py

@@ -552,5 +552,25 @@ def test_add_model_with_existing_models(api, mock_map_data, mock_model_data, moc
 def test_image_tile_url(api, mock_map_data):
     map = Map(api, uuid=mock_map_data['uuid'], data=mock_map_data)
 
-    assert map.image_tile_url() == f"{map.BASE_ENDPOINT}{map.endpoint}"+"{z}/{x}/{y}.png"
-    assert map.image_tile_url(x=1, y=2, z=3, format='.pbf') == f"{map.BASE_ENDPOINT}{map.endpoint}3/1/2.pbf"
+    assert map.image_tile_url() == f"{map.api.base_url}{map.endpoint}tiles/"+"{z}/{x}/{y}.png"
+    assert map.image_tile_url(x=1, y=2, z=3, format='.pbf') == f"{map.api.base_url}{map.endpoint}tiles/3/1/2.pbf"
+
+    # apikey
+    api.access_token = ''
+    api.apikey = 'apikey@1234'
+
+    assert map.image_tile_url() == f"{map.api.base_url}{map.endpoint}tiles/"+"{z}/{x}/{y}.png?apikey=apikey@1234"
+
+
+def test_export_map_to_image(api, mock_map_data, mock_success_task_data):
+    map = Map(api, uuid=mock_map_data['uuid'], data=mock_map_data)
+
+    api.post.return_value = {
+        'task_id': mock_success_task_data['uuid']
+    }
+    api.get_task.return_value = Task(api, mock_success_task_data['uuid'], mock_success_task_data)
+
+    task = map.export_map_to_image(bbox=[50.275, 35.1195, 51.4459, 36.0416], width=100, height=100)
+    
+    api.post.assert_called_once_with('maps/da9a505b-7b51-4042-a3ba-c821e4f2cd34/export/?uuid=da9a505b-7b51-4042-a3ba-c821e4f2cd34&bbox=%5B50.275%2C+35.1195%2C+51.4459%2C+36.0416%5D&width=100&height=100')
+    assert type(task) == Task

{geobox-1.3.4 → geobox-1.4.0}/tests/test_plan.py

@@ -52,6 +52,18 @@ def test_get_plan(api, mock_plan_data):
     assert plan.data == mock_plan_data
 
 
+def test_get_plan_by_name(api, mock_plan_data):
+    api.get.return_value = [mock_plan_data]
+    plan = Plan.get_plan_by_name(api, name=mock_plan_data['name'])
+    api.get.assert_called_once_with(f"{Plan.BASE_ENDPOINT}?f=json&q=name+%3D+%27test%27&return_count=False&skip=0&limit=10&shared=False")
+    assert type(plan) == Plan
+    assert plan.plan_id == mock_plan_data['id']
+    assert plan.data == mock_plan_data
+    # not found
+    plan = Plan.get_plan_by_name(api, name='not_found')
+    assert plan == None
+
+
 def test_update(api, mock_plan_data):
     plan = Plan(api, mock_plan_data['id'], mock_plan_data)
     updated_data = {**mock_plan_data,

{geobox-1.3.4 → geobox-1.4.0}/tests/test_raster.py

@@ -249,7 +249,12 @@ def test_get_render_png_url(api, mock_raster_data):
     raster = Raster(api, uuid=mock_raster_data['uuid'], data=mock_raster_data)
     url = raster.get_render_png_url(x=10, y=20, z=1, indexes=1)
     assert url == f"{raster.api.base_url}{raster.endpoint}render/1/10/20.png?indexes=1"
-
+    # apikey
+    api.access_token = ''
+    api.apikey = 'apikey_1234'
+    url = raster.get_render_png_url(x=10, y=20, z=1, indexes=1)
+    assert url == f"{raster.api.base_url}{raster.endpoint}render/1/10/20.png?indexes=1&apikey=apikey_1234"
+    
 
 def test_get_tile_png_url(api, mock_raster_data):
     """Test getting tile PNG URL."""

{geobox-1.3.4 → geobox-1.4.0}/tests/test_task.py

@@ -10,6 +10,7 @@ from geobox.enums import LayerType, TaskStatus
 from geobox.vectorlayer import VectorLayer
 from geobox.raster import Raster
 from geobox.model3d import Model
+from geobox.tile3d import Tile3d
 
 
 def test_init(api, mock_success_task_data):
@@ -26,7 +27,7 @@ def test_repr(api, mock_success_task_data):
     assert repr(task) == f"Task(uuid={task.uuid}, name={mock_success_task_data['name']})"
 
 
-def test_output_asset_property(api, mock_publish_task_data, mock_vector_data, mock_raster_data, mock_model_data, mock_file_data):
+def test_output_asset_property(api, mock_publish_task_data, mock_vector_data, mock_raster_data, mock_model_data, mock_file_data, mock_tile3d_data):
     # raster layer
     task = Task(api, uuid=mock_publish_task_data['uuid'], data=mock_publish_task_data)
     api.get_raster.return_value = Raster(api, mock_raster_data['uuid'], data=mock_raster_data)
@@ -66,9 +67,19 @@ def test_output_asset_property(api, mock_publish_task_data, mock_vector_data, mo
     assert task.output_asset.uuid == expected_layer.uuid
     assert task.output_asset.data == expected_layer.data
     assert type(task.output_asset) == File
+    # tile3d
+    mock_publish_task_data['result']['3dtiles_uuid'] = mock_publish_task_data['result']['file_uuid']
+    del mock_publish_task_data['result']['file_uuid']
+    task = Task(api, uuid=mock_publish_task_data['uuid'], data=mock_publish_task_data)
+    api.get_3dtile.return_value = Tile3d(api, mock_tile3d_data['uuid'], data=mock_tile3d_data)
+    expected_layer = Tile3d(api, mock_tile3d_data['uuid'], data=mock_tile3d_data)
+    assert task.output_asset.name == expected_layer.name
+    assert task.output_asset.uuid == expected_layer.uuid
+    assert task.output_asset.data == expected_layer.data
+    assert type(task.output_asset) == Tile3d
     #None
     mock_publish_task_data['name'] = 'import'
-    del mock_publish_task_data['result']['file_uuid']
+    del mock_publish_task_data['result']['3dtiles_uuid']
     task = Task(api, uuid=mock_publish_task_data['uuid'], data=mock_publish_task_data)
     assert task.output_asset == None
 

{geobox-1.3.4 → geobox-1.4.0}/tests/test_tile3d.py

@@ -128,3 +128,18 @@ def test_get_shared_users(api, mock_tile3d_data, mock_user_data):
         assert result[0].last_name == 'test 1'
         assert result[1].first_name == 'test 2'
         assert result[1].last_name == 'test 2'
+
+
+def test_get_tileset_json(api, mock_tile3d_data):
+    mock_response = {
+        'key': 'value'
+    }
+    with patch.object(api, 'get', return_value=mock_response):
+        tile3d = Tile3d(api, uuid=mock_tile3d_data['uuid'], data=mock_tile3d_data)
+        result = tile3d.get_tileset_json()
+        
+        assert result == mock_response
+
+        api.get.assert_called_once_with('3dtiles/fa1e14c3-bb36-4541-a7c3-d0a7f70d8852/tileset.json')
+
+