geobox 1.4.0__tar.gz → 1.4.1__tar.gz

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

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

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

@@ -29,7 +29,7 @@ from .route import Routing
 from .plan import Plan
 from .dashboard import Dashboard
 from .basemap import Basemap
-from .attachment import Attachment, AttachmentResourceType
+from .attachment import Attachment
 from .apikey import ApiKey
 from .log import Log
 from .usage import Usage, UsageScale, UsageParam
@@ -2294,13 +2294,12 @@ class GeoboxClient:
         return Basemap.proxy_basemap(self, url)
     
 
-    def get_attachments(self, resource_type: AttachmentResourceType, resource_uuid: str, **kwargs) -> Union[List['Attachment'], int]:
+    def get_attachments(self, resource: Union['Map', 'VectorLayer', 'VectorLayerView'], **kwargs) -> List['Attachment']:
         """
-        Get list of attachments with optional filtering and pagination.
+        Get the resouces attachments
 
         Args:
-            resource_type (AttachmentResourceType): The resource type of the attachment. options are: Map, Vector, View
-            resource_uuid (str): The Resoource uuid of the attachment.
+            resource (Map | VectorLayer | VectorLayerView): options are: Map, Vector, View objects
 
         Keyword Args:
             element_id (str): the id of the element with attachment.
@@ -2313,12 +2312,17 @@ class GeoboxClient:
         Returns:
             List[Attachment] | int: A list of attachments instances or the total number of attachments.
 
+        Raises:
+            TypeError: if the resource type is not supported
+
         Example:
             >>> from geobox import GeoboxClient
+            >>> from geobox.attachment import Attachment
             >>> client = GeoboxClient()
-            >>> attachments = client.get_attachments(q="name LIKE '%My attachment%'")
+            >>> map = client.get_maps()[0]
+            >>> attachments = client.get_attachments(resource=map)
         """
-        return Attachment.get_attachments(self, resource_type, resource_uuid, **kwargs)
+        return Attachment.get_attachments(self, resource=resource, **kwargs)
     
 
     def create_attachment(self,

{geobox-1.4.0 → geobox-1.4.1}/geobox/attachment.py

@@ -3,7 +3,6 @@ from urllib.parse import urljoin
 
 from .base import Base
 from .utils import clean_data
-from .enums import AttachmentResourceType
 from .map import Map
 from .vectorlayer import VectorLayer
 from .view import VectorLayerView
@@ -56,14 +55,13 @@ class Attachment(Base):
 
 
     @classmethod
-    def get_attachments(cls, api: 'GeoboxClient', resource_type: AttachmentResourceType, resource_uuid: str, **kwargs) -> Union[List['Attachment'], int]:
+    def get_attachments(cls, api: 'GeoboxClient', resource: Union['Map', 'VectorLayer', 'VectorLayerView'], **kwargs) -> Union[List['Attachment'], int]:
         """
         Get list of attachments with optional filtering and pagination.
 
         Args:
             api (GeoboxClient): The GeoboxClient instance for making requests.
-            resource_type (AttachmentResourceType): The resource type of the attachment. options are: Map, Vector, View
-            resource_uuid (str): The Resoource uuid of the attachment.
+            resource (Map | VectorLayer | VectorLayerView): options are: Map, Vector, View objects
 
         Keyword Args:
             element_id (str): the id of the element with attachment.
@@ -76,17 +74,34 @@ class Attachment(Base):
         Returns:
             List[Attachment] | int: A list of attachments instances or the total number of attachments.
 
+        Raises:
+            TypeError: if the resource type is not supported
+
         Example:
             >>> from geobox import GeoboxClient
             >>> from geobox.attachment import Attachment
             >>> client = GeoboxClient()
-            >>> attachments = Attachment.get_attachments(client, q="name LIKE '%My attachment%'")
+            >>> map = client.get_maps()[0]
+            >>> attachments = Attachment.get_attachments(client, resource=map, q="name LIKE '%My attachment%'")
             or
-            >>> attachments = client.get_attachments(q="name LIKE '%My attachment%'")
+            >>> attachments = client.get_attachments(resource=map, q="name LIKE '%My attachment%'")
         """
+        if type(resource) == VectorLayer:
+            resource_type = 'vector'
+
+        elif type(resource) == VectorLayerView:
+            resource_type = 'view'
+
+        elif type(resource) == Map:
+            resource_type = 'map'
+
+        else:
+            raise TypeError('resource must be a vectorlayer or view or map object')
+
+
         params = {
-           'resource_type': resource_type.value,
-           'resource_uuid': resource_uuid,
+           'resource_type': resource_type,
+           'resource_uuid': resource.uuid,
            'element_id': kwargs.get('element_id'),
            'search': kwargs.get('search'),
            'order_by': kwargs.get('order_by'),
@@ -155,13 +170,13 @@ class Attachment(Base):
             ...                                             description="Attachment Description")
         """
         if isinstance(resource, VectorLayer):
-            resource_type = AttachmentResourceType.Vector.value
+            resource_type = 'vector'
 
         if isinstance(resource, VectorLayerView):
-            resource_type = AttachmentResourceType.View.value
+            resource_type = 'view'
 
         if isinstance(resource, Map):
-            resource_type = AttachmentResourceType.Map.value
+            resource_type = 'map'
 
         data = {
             "name": name,
@@ -171,7 +186,7 @@ class Attachment(Base):
             "loc_y": loc_y,
             "resource_type": resource_type,
             "resource_uuid": resource.uuid,
-            "element_id": feature.id,
+            "element_id": feature.id if feature else None,
             "file_id": file.id
             }
         return super()._create(api, cls.BASE_ENDPOINT, data, factory_func=lambda api, item: Attachment(api, item['id'], item))

{geobox-1.4.0 → geobox-1.4.1}/geobox/basemap.py

@@ -95,8 +95,7 @@ class Basemap(Base):
         Returns:
             str: the thumbnail url
         """
-        endpoint = f"{self.api.base_url}{self.endpoint}/thumbnail.png" 
-        return endpoint
+        return super().thumbnail()
     
 
     @property

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

@@ -272,14 +272,6 @@ class UserStatus(Enum):
     DISABLED = "Disabled"
 
 
-class AttachmentResourceType(Enum):
-    Map = "map"
-
-    Vector = "vector"
-
-    View = "view"
-
-
 class MaxLogPolicy(Enum):
     OverwriteFirstLog = "OverwriteFirstLog"
 

{geobox-1.4.0 → geobox-1.4.1}/geobox/log.py

@@ -6,6 +6,7 @@ from .base import Base
 
 if TYPE_CHECKING:
     from . import GeoboxClient
+    from .user import User
 
 
 class Log(Base):
@@ -98,4 +99,22 @@ class Log(Base):
             >>> log.delete()
         """
         super().delete(self.endpoint)
-        self.log_id = None
+        self.log_id = None
+
+
+    @property
+    def user(self) -> Union['User', None]:
+        """
+        Get the owner user for the log
+
+        Returns:
+            User | None: if the log has owner user 
+
+        Example:
+            >>> from geobox import Geobox
+            >>> from geopox.log import Log
+            >>> client = GeoboxClient()
+            >>> log = Log.get_logs(client)[0]
+            >>> log.user
+        """
+        return self.api.get_user(self.owner_id)

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

@@ -4,11 +4,15 @@ from urllib.parse import urljoin, urlencode
 from .base import Base
 from .utils import clean_data, join_url_params
 from .model3d import Model
+from .file import File
+from .feature import Feature
 
 if TYPE_CHECKING:
     from . import GeoboxClient
     from .user import User
     from .task import Task
+    from .attachment import Attachment
+
 
 
 class Map(Base):
@@ -899,3 +903,80 @@ class Map(Base):
         endpoint = f"{endpoint}?{query_string}"
         response = self.api.post(endpoint)
         return self.api.get_task(response['task_id'])
+
+
+    def get_attachments(self, **kwargs) -> List['Attachment']:
+        """
+        Get the resouces attachments
+
+        Keyword Args:
+            element_id (str): the id of the element with attachment.
+            search (str): search term for keyword-based searching among all textual fields.
+            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.
+            skip (int): Number of items to skip. default is 0.
+            limit (int): Number of items to return. default is 10.
+            return_count (bool): Whether to return total count. default is False.
+
+        Returns:
+            List[Attachment] | int: A list of attachments instances or the total number of attachments.
+
+        Raises:
+            TypeError: if the resource type is not supported
+
+        Example:
+            >>> from geobox import GeoboxClient
+            >>> from geobox.map import Map
+            >>> client = GeoboxClient()
+            >>> map = Map.get_map(client, uuid="12345678-1234-5678-1234-567812345678")
+            >>> map.get_attachments()
+        """
+        from .attachment import Attachment
+
+        return Attachment.get_attachments(self.api, resource=self, **kwargs)
+    
+    
+    def create_attachment(self, 
+                            name: str, 
+                            loc_x: int,
+                            loc_y: int,
+                            file: 'File',
+                            feature: 'Feature' = None,
+                            display_name: str = None, 
+                            description: str = None) -> 'Attachment':
+        """
+        Create a new Attachment.
+
+        Args:
+            name (str): The name of the scene.
+            loc_x (int): x parameter of the attachment location.
+            loc_y (int): y parameter of the attachment location.
+            file (File): the file object.
+            feature (Feature, optional): the feature object.
+            display_name (str, optional): The display name of the scene.
+            description (str, optional): The description of the scene.
+
+        Returns:
+            Attachment: The newly created Attachment instance.
+
+        Raises:
+            ValidationError: If the Attachment data is invalid.
+
+        Example:
+            >>> from geobox import GeoboxClient
+            >>> from geobox.map import Map
+            >>> client = GeoboxClient()
+            >>> map = Map.get_map(client, uuid="12345678-1234-5678-1234-567812345678")
+            >>> file = client.get_files()[0]
+            >>> map.create_attachment(name='test', loc_x=10, loc_y=10, file=file)
+        """
+        from .attachment import Attachment
+
+        return Attachment.create_attachment(self.api,
+                                            name=name,
+                                            loc_x=loc_x,
+                                            loc_y=loc_y,
+                                            resource=self,
+                                            file=file,
+                                            feature=feature,
+                                            display_name=display_name,
+                                            description=description)

{geobox-1.4.0 → geobox-1.4.1}/geobox/vectorlayer.py

@@ -11,12 +11,13 @@ from .task import Task
 from .enums import InputGeomType, FileOutputFormat
 from .version import VectorLayerVersion
 
-
 if TYPE_CHECKING:
     from .api import GeoboxClient
     from .view import VectorLayerView
     from .user import User
     from .file import File
+    from .attachment import Attachment
+
 
 class VectorLayer(Base):
     """
@@ -1227,4 +1228,81 @@ class VectorLayer(Base):
             >>> layer.prune_edited_areas()
         """
         endpoint = urljoin(self.endpoint, 'prune/')
-        return self.api.post(endpoint)
+        return self.api.post(endpoint)
+    
+
+    def get_attachments(self, **kwargs) -> List['Attachment']:
+        """
+        Get the resouces attachments
+
+        Keyword Args:
+            element_id (str): the id of the element with attachment.
+            search (str): search term for keyword-based searching among all textual fields.
+            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.
+            skip (int): Number of items to skip. default is 0.
+            limit (int): Number of items to return. default is 10.
+            return_count (bool): Whether to return total count. default is False.
+
+        Returns:
+            List[Attachment] | int: A list of attachments instances or the total number of attachments.
+
+        Raises:
+            TypeError: if the resource type is not supported
+
+        Example:
+            >>> from geobox import GeoboxClient
+            >>> from geobox.vectorlayer import VectorLayer
+            >>> client = GeoboxClient()
+            >>> layer = VectorLayer.get_vector(api=client, uuid="12345678-1234-5678-1234-567812345678")
+            >>> layer.get_attachments()
+        """
+        from .attachment import Attachment
+
+        return Attachment.get_attachments(self.api, resource=self, **kwargs)
+    
+    
+    def create_attachment(self, 
+                            name: str, 
+                            loc_x: int,
+                            loc_y: int,
+                            file: 'File',
+                            feature: 'Feature' = None,
+                            display_name: str = None, 
+                            description: str = None) -> 'Attachment':
+        """
+        Create a new Attachment.
+
+        Args:
+            name (str): The name of the scene.
+            loc_x (int): x parameter of the attachment location.
+            loc_y (int): y parameter of the attachment location.
+            file (File): the file object.
+            feature (Feature, optional): the feature object.
+            display_name (str, optional): The display name of the scene.
+            description (str, optional): The description of the scene.
+
+        Returns:
+            Attachment: The newly created Attachment instance.
+
+        Raises:
+            ValidationError: If the Attachment data is invalid.
+
+        Example:
+            >>> from geobox import GeoboxClient
+            >>> from geobox.vectorlayer import VectorLayer
+            >>> client = GeoboxClient()
+            >>> layer = VectorLayer.get_vector(api=client, uuid="12345678-1234-5678-1234-567812345678")
+            >>> file = client.get_files()[0]
+            >>> layer.create_attachment(name='test', loc_x=10, loc_y=10, file=file)
+        """
+        from .attachment import Attachment
+
+        return Attachment.create_attachment(self.api,
+                                            name=name,
+                                            loc_x=loc_x,
+                                            loc_y=loc_y,
+                                            resource=self,
+                                            file=file,
+                                            feature=feature,
+                                            display_name=display_name,
+                                            description=description)

{geobox-1.4.0 → geobox-1.4.1}/geobox/view.py

@@ -7,9 +7,11 @@ if TYPE_CHECKING:
     from . import GeoboxClient
     from .field import Field
     from .user import User
-    from .enums import InputGeomType, FieldType
+    from .enums import InputGeomType
     from .task import Task
     from .file import File
+    from .attachment import Attachment
+
 
 
 class VectorLayerView(VectorLayer):
@@ -862,3 +864,80 @@ class VectorLayerView(VectorLayer):
             >>> view.prune_edited_areas()
         """
         return super().prune_edited_areas()
+
+
+    def get_attachments(self, **kwargs) -> List['Attachment']:
+        """
+        Get the resouces attachments
+
+        Keyword Args:
+            element_id (str): the id of the element with attachment.
+            search (str): search term for keyword-based searching among all textual fields.
+            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.
+            skip (int): Number of items to skip. default is 0.
+            limit (int): Number of items to return. default is 10.
+            return_count (bool): Whether to return total count. default is False.
+
+        Returns:
+            List[Attachment] | int: A list of attachments instances or the total number of attachments.
+
+        Raises:
+            TypeError: if the resource type is not supported
+
+        Example:
+            >>> from geobox import GeoboxClient
+            >>> from geobox.view import VectorLayerView
+            >>> client = GeoboxClient()
+            >>> view = VectorLayerView.get_view(client, uuid="12345678-1234-5678-1234-567812345678")
+            >>> view.get_attachments()
+        """
+        from .attachment import Attachment
+
+        return Attachment.get_attachments(self.api, resource=self, **kwargs)
+    
+    
+    def create_attachment(self, 
+                            name: str, 
+                            loc_x: int,
+                            loc_y: int,
+                            file: 'File',
+                            feature: 'Feature' = None,
+                            display_name: str = None, 
+                            description: str = None) -> 'Attachment':
+        """
+        Create a new Attachment.
+
+        Args:
+            name (str): The name of the scene.
+            loc_x (int): x parameter of the attachment location.
+            loc_y (int): y parameter of the attachment location.
+            file (File): the file object.
+            feature (Feature, optional): the feature object.
+            display_name (str, optional): The display name of the scene.
+            description (str, optional): The description of the scene.
+
+        Returns:
+            Attachment: The newly created Attachment instance.
+
+        Raises:
+            ValidationError: If the Attachment data is invalid.
+
+        Example:
+            >>> from geobox import GeoboxClient
+            >>> from geobox.view import VectorLayerView
+            >>> client = GeoboxClient()
+            >>> view = VectorLayerView.get_view(client, uuid="12345678-1234-5678-1234-567812345678")
+            >>> file = client.get_files()[0]
+            >>> view.create_attachment(name='test', loc_x=10, loc_y=10, file=file)
+        """
+        from .attachment import Attachment
+
+        return Attachment.create_attachment(self.api,
+                                            name=name,
+                                            loc_x=loc_x,
+                                            loc_y=loc_y,
+                                            resource=self,
+                                            file=file,
+                                            feature=feature,
+                                            display_name=display_name,
+                                            description=description)

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

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

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

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

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

@@ -1812,7 +1812,7 @@ def test_get_attachments(mock_attachment_data, mock_vector_data):
         
         client = GeoboxClient(username='testuser', password='testpassword')
         layer = VectorLayer(client, mock_vector_data['uuid'], LayerType.Polygon, mock_vector_data)
-        attachments = client.get_attachments(resource_type=AttachmentResourceType.Vector, resource_uuid=layer.uuid)
+        attachments = client.get_attachments(resource=layer)
         
         assert len(attachments) == 2
         assert isinstance(attachments[0], Attachment)

{geobox-1.4.0 → geobox-1.4.1}/tests/test_attachment.py

@@ -1,6 +1,6 @@
 import pytest
 
-from geobox.attachment import Attachment, AttachmentResourceType
+from geobox.attachment import Attachment
 from geobox.file import File
 from geobox.vectorlayer import VectorLayer, LayerType
 from geobox.feature import Feature
@@ -31,12 +31,16 @@ def test_file(api, mock_attachment_data):
 def test_get_attachments(api, mock_attachment_data, mock_vector_data):
     api.get.return_value = [mock_attachment_data, mock_attachment_data]
     layer = VectorLayer(api, mock_vector_data['uuid'], LayerType.Polygon, mock_vector_data)
-    attachments = Attachment.get_attachments(api, resource_type=AttachmentResourceType.Vector, resource_uuid=layer.uuid)
+    attachments = Attachment.get_attachments(api, resource=layer)
     api.get.assert_called_once_with(f'{Attachment.BASE_ENDPOINT}?resource_type=vector&resource_uuid=297fa7ca-877a-400c-8003-d65de9e791c2&skip=0&limit=10')
     assert len(attachments) == 2
     assert type(attachments[0]) == Attachment
     assert attachments[0].data == mock_attachment_data
 
+    # error
+    with pytest.raises(TypeError):
+        Attachment.get_attachments(api, resource='')
+
 
 def test_create_attachment(api, mock_attachment_data, mock_vector_data, mock_feature_data, mock_view_data, mock_map_data):
     api.post.return_value = mock_attachment_data
@@ -104,7 +108,7 @@ def test_update_attachment(api, mock_attachment_data):
 def test_update(api, mock_attachment_data, mock_vector_data):
     api.get.return_value = [mock_attachment_data, mock_attachment_data]
     layer = VectorLayer(api, mock_attachment_data['key'].split(':')[1], LayerType.Polygon, mock_vector_data)
-    attachment = Attachment.get_attachments(api, resource_type=AttachmentResourceType.Vector, resource_uuid=layer.uuid)[0]
+    attachment = Attachment.get_attachments(api, resource=layer)[0]
     expected_data = {'name': 'updated_name', 
             'display_name': 'updated display name', 
             'description': 'updated description', 
@@ -122,10 +126,10 @@ def test_update(api, mock_attachment_data, mock_vector_data):
     assert attachment.data == updated_data
 
 
-def test_delete(api, mock_attachment_data, mock_vector_data):
+def test_delete(api, mock_attachment_data, mock_map_data):
     api.get.return_value = [mock_attachment_data, mock_attachment_data]
-    layer = VectorLayer(api, mock_attachment_data['key'].split(':')[1], LayerType.Polygon, mock_vector_data)
-    attachment = Attachment.get_attachments(api, resource_type=AttachmentResourceType.Vector, resource_uuid=layer.uuid)[0]
+    map = Map(api, mock_attachment_data['key'].split(':')[1], mock_map_data)
+    attachment = Attachment.get_attachments(api, resource=map)[0]
     endpoint = attachment.endpoint
     attachment.delete()
     api.delete.assert_called_once_with(endpoint)
@@ -133,10 +137,10 @@ def test_delete(api, mock_attachment_data, mock_vector_data):
     assert attachment.endpoint is None
 
 
-def test_thumbnail(api, mock_attachment_data, mock_vector_data):
+def test_thumbnail(api, mock_attachment_data, mock_view_data):
     api.get.return_value = [mock_attachment_data, mock_attachment_data]
-    layer = VectorLayer(api, mock_attachment_data['key'].split(':')[1], LayerType.Polygon, mock_vector_data)
-    attachment = Attachment.get_attachments(api, resource_type=AttachmentResourceType.Vector, resource_uuid=layer.uuid)[0]
+    view = VectorLayerView(api, mock_attachment_data['key'].split(':')[1], LayerType.Polygon, mock_view_data)
+    attachment = Attachment.get_attachments(api, resource=view)[0]
     thumbnail_url = attachment.thumbnail
     assert thumbnail_url == f"{api.base_url}{attachment.endpoint}thumbnail"
 

{geobox-1.4.0 → geobox-1.4.1}/tests/test_basemap.py

@@ -42,7 +42,7 @@ def test_get_basemap(api, mock_basemap_data, mock_basemap_list_data):
 def test_thumbnail(api, mock_basemap_data):
     basemap = Basemap(api, mock_basemap_data)
     thumbnail_url = basemap.thumbnail
-    assert thumbnail_url == f"{api.base_url}{basemap.endpoint}/thumbnail.png"
+    assert thumbnail_url == f"{api.base_url}{basemap.endpoint}thumbnail.png"
 
 
 def test_wmts(api, mock_basemap_data):

{geobox-1.4.0 → geobox-1.4.1}/tests/test_log.py

@@ -2,6 +2,7 @@ import pytest
 from unittest.mock import patch
 
 from geobox.log import Log
+from geobox.user import User
 
 def test_init(api, mock_log_data):
     log = Log(api, mock_log_data['id'], mock_log_data)
@@ -32,3 +33,9 @@ def test_delete(api, mock_log_data):
     assert log.log_id is None
     assert log.endpoint is None
 
+
+def test_user_property(api, mock_log_data, mock_user_data):
+    log = Log(api, mock_log_data['id'], mock_log_data)
+    api.get_user.return_value = User(api, mock_user_data['1']['id'], mock_user_data['1'])
+    user = log.user
+    assert user.data == mock_user_data['1']

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

@@ -7,6 +7,8 @@ from geobox.map import Map
 from geobox.model3d import Model
 from geobox.user import User
 from geobox.task import Task
+from geobox.attachment import Attachment
+from geobox.file import File
 
 
 def test_init(api, mock_map_data):
@@ -574,3 +576,23 @@ def test_export_map_to_image(api, mock_map_data, mock_success_task_data):
     
     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
+
+
+def test_get_attachments(api, mock_map_data, mock_attachment_data):
+    map = Map(api, uuid=mock_map_data['uuid'], data=mock_map_data)
+
+    api.get.return_value = [mock_attachment_data, mock_attachment_data, mock_attachment_data]
+
+    attachments = map.get_attachments()
+    assert len(attachments) == 3
+    assert type(attachments[0]) == Attachment
+
+
+def test_create_attachment(api, mock_map_data, mock_attachment_data, mock_file_data):
+    map = Map(api, uuid=mock_map_data['uuid'], data=mock_map_data)
+    file = File(api, uuid=mock_file_data['uuid'], data=mock_file_data)
+
+    api.post.return_value = mock_attachment_data
+    attachment = map.create_attachment(name='test', loc_x=10, loc_y=10, file=file)
+    assert type(attachment) == Attachment
+    assert attachment.data == mock_attachment_data

{geobox-1.4.0 → geobox-1.4.1}/tests/test_vectorlayer.py

@@ -11,6 +11,7 @@ from geobox.view import VectorLayerView
 from geobox.user import User
 from geobox.task import Task
 from geobox.file import File
+from geobox.attachment import Attachment
 from geobox.exception import NotFoundError
 from geobox.utils import clean_data
 
@@ -750,3 +751,26 @@ def test_prune_edited_areas(api, mock_vector_data, layer_type):
     layer = VectorLayer(api, uuid=mock_vector_data['uuid'], data=mock_vector_data, layer_type=layer_type)
     layer.prune_edited_areas()
     api.post.assert_called_once_with(f'{layer.endpoint}prune/')
+
+
+@pytest.mark.parametrize("layer_type", [type for type in LayerType])
+def test_get_attachments(api, mock_vector_data, mock_attachment_data, layer_type):
+    layer = VectorLayer(api, uuid=mock_vector_data['uuid'], data=mock_vector_data, layer_type=layer_type)
+
+    api.get.return_value = [mock_attachment_data, mock_attachment_data, mock_attachment_data]
+
+    attachments = layer.get_attachments()
+    assert len(attachments) == 3
+    assert type(attachments[0]) == Attachment
+
+
+@pytest.mark.parametrize("layer_type", [type for type in LayerType])
+def test_create_attachment(api, mock_vector_data, mock_attachment_data, mock_file_data, layer_type):
+    layer = VectorLayer(api, uuid=mock_vector_data['uuid'], data=mock_vector_data, layer_type=layer_type)
+
+    file = File(api, uuid=mock_file_data['uuid'], data=mock_file_data)
+
+    api.post.return_value = mock_attachment_data
+    attachment = layer.create_attachment(name='test', loc_x=10, loc_y=10, file=file)
+    assert type(attachment) == Attachment
+    assert attachment.data == mock_attachment_data

{geobox-1.4.0 → geobox-1.4.1}/tests/test_view.py

@@ -9,6 +9,7 @@ from geobox.field import Field, FieldType
 from geobox.exception import NotFoundError
 from geobox.task import Task
 from geobox.file import File
+from geobox.attachment import Attachment
 from geobox.utils import clean_data
 
 
@@ -711,4 +712,37 @@ def test_prune_edited_areas(api, mock_view_data, layer_type):
         data=mock_view_data
     )
     view.prune_edited_areas()
-    api.post.assert_called_once_with(f'{view.endpoint}prune/')
+    api.post.assert_called_once_with(f'{view.endpoint}prune/')
+
+
+@pytest.mark.parametrize("layer_type", [type for type in LayerType])
+def test_get_attachments(api, mock_view_data, mock_attachment_data, layer_type):
+    view = VectorLayerView(
+        api=api,
+        uuid=mock_view_data['uuid'],
+        layer_type=layer_type,
+        data=mock_view_data
+    )
+
+    api.get.return_value = [mock_attachment_data, mock_attachment_data, mock_attachment_data]
+
+    attachments = view.get_attachments()
+    assert len(attachments) == 3
+    assert type(attachments[0]) == Attachment
+
+
+@pytest.mark.parametrize("layer_type", [type for type in LayerType])
+def test_create_attachment(api, mock_view_data, mock_attachment_data, mock_file_data, layer_type):
+    view = VectorLayerView(
+        api=api,
+        uuid=mock_view_data['uuid'],
+        layer_type=layer_type,
+        data=mock_view_data
+    )
+
+    file = File(api, uuid=mock_file_data['uuid'], data=mock_file_data)
+
+    api.post.return_value = mock_attachment_data
+    attachment = view.create_attachment(name='test', loc_x=10, loc_y=10, file=file)
+    assert type(attachment) == Attachment
+    assert attachment.data == mock_attachment_data