geobox 2.2.6__py3-none-any.whl → 2.4.0__py3-none-any.whl

geobox/aio/feature.py

@@ -1,13 +1,12 @@
 from urllib.parse import urljoin
-from typing import Optional, List, Dict, Any, TYPE_CHECKING
+from typing import Optional, List, Dict, Any, TYPE_CHECKING, Union
 
 from .base import AsyncBase
 from ..enums import FeatureType
 
 if TYPE_CHECKING:
-    from .vectorlayer import VectorLayer
-    from ..api import GeoboxClient
-    from ..feature import Feature
+    from .vectorlayer import VectorLayer, AsyncVectorLayer
+    from .table import AsyncTable, AsyncTableRow, AsyncRelationship
 
 
 class AsyncFeature(AsyncBase):
@@ -522,26 +521,182 @@ class AsyncFeature(AsyncBase):
         return self
 
 
-    def to_sync(self, sync_client: 'GeoboxClient') -> 'Feature':
+    async def _get_other_side_of_relationship(
+        self, 
+        relationship: 'AsyncRelationship',
+    ) -> Union['AsyncTable', 'AsyncVectorLayer']:
         """
-        [async] Switch to sync version of the feature instance to have access to the sync methods
+        [async] Determine which side of a relationship this table is on and return the opposite side.
+        
+        Used internally to navigate bidirectional relationships.
+        
+        Args:
+            relationship (AsyncRelationship): The relationship to examine.
+            
+        Returns:
+            AsyncTable | AsyncVectorLayer: The endpoint (table or layer) on the opposite side
+            of the relationship from this table.
+            
+        Raises:
+            ValueError: If this table is not part of the given relationship.
+            
+        Note:
+            This method assumes the table is either the source or target,
+            not the relation table in Many-to-Many relationships.
+        """
+        if relationship.source_id == self.layer.id:
+            return await relationship.get_target()
+
+        if relationship.target_id == self.layer.id:
+            return await relationship.get_source()
 
+        raise ValueError("Relationship does not involve this table.")
+
+
+    async def _fetch_related_from_target(
+        self, 
+        target: Union['AsyncTable', 'AsyncVectorLayer'], 
+        relationship_uuid: str,
+    ) -> Union[List['AsyncTableRow'], List['AsyncFeature']]:
+        """
+        [async] Fetch related rows/features from a relationship target.
+        
+        Internal helper that dispatches to the appropriate API method
+        based on target type.
+        
         Args:
-            sync_client (GeoboxClient): The sync version of the GeoboxClient instance for making requests.
+            target (AsyncTable | AsyncVectorLayer): The target endpoint (Table or VectorLayer) to query.
+            relationship_uuid (str): UUID of the relationship to traverse.
+            
+        Raises:
+            TypeError: If target is not a Table or VectorLayer.
 
         Returns:
-            Feature: the sync instance of the feature.
+            List[AsyncTableRow] | List[AsyncFeature]: Related rows or features.
+        """
+        from .table import AsyncTable
+        from .vectorlayer import AsyncVectorLayer
+
+        if isinstance(target, AsyncTable):
+            return await target.get_rows(
+                relationship_uuid=relationship_uuid,
+                related_record_id=self.id,
+            )
+
+        if isinstance(target, AsyncVectorLayer):
+            return await target.get_features(
+                relationship_uuid=relationship_uuid,
+                related_record_id=self.id,
+            )
+
+        raise TypeError(f"Unsupported target type: {type(target)}")
+
+
+    async def get_related_records(self,
+        relationship_uuid: str,
+    ) -> Union[List['AsyncTableRow'], List['AsyncFeature']]:
+        """
+        [async] Get the related records on the *other side* of the relationship that are linked to this row
+
+        Args:
+            relationship_uuid (str): The uuid of relationship
+
+        Returns:
+            List[AsyncTableRow] | List[AsyncFeature]: a list of the related records
+
+        Raises:
+            ValueError:
+                If the given relationship does not involve the current table
+                (i.e., this row is neither the source nor the target of the relationship).
+
+            TypeError:
+                If the relationship target type is not supported for fetching
+                related records.
 
         Example:
-            >>> from geobox import Geoboxclient
             >>> from geobox.aio import AsyncGeoboxClient
-            >>> client = GeoboxClient()
-            >>> async with AsyncGeoboxClient() as async_client:
-            >>>     layer = await async_client.get_vector(uuid="12345678-1234-5678-1234-567812345678")
-            >>>     feature = await layer.get_feature(id=1, srid=3857)
-            >>>     sync_feature = feature.to_sync(client)
+            >>> async with AsyncGeoboxClient() as client:
+            >>>     layer = await client.get_vector(uuid="12345678-1234-5678-1234-567812345678")
+            >>>     feature = await layer.get_feature(feature_id=1)
+            >>>     related_records = await feature.get_related_records(relationship_uuid="12345678-1234-5678-1234-567812345678")
+        """
+        relationship = await self.api.get_relationship(relationship_uuid)
+
+        other_side = await self._get_other_side_of_relationship(relationship)
+
+        return await self._fetch_related_from_target(
+            target=other_side,
+            relationship_uuid=relationship_uuid,
+        )
+
+
+    async def associate_with(
+        self,
+        relationship_uuid: str,
+        *,
+        target_ids: Optional[List[int]] = None,
+        q: Optional[str] = None,
+    ) -> Dict:
         """
-        from ..feature import Feature
+        [async] Create relationships between the source record and target records
+
+        Args:
+            relationship_uuid (str): the relationship uuid
+            target_ids (List[int], optional): a list of target record ids to be associated with the current record
+            q (str, optional): query filter on target layer or table to select which target features or rows that are going to be related to the current record
+
+        Returns:
+            Dict: the record association result
 
-        sync_layer = self.layer.to_sync(sync_client=sync_client)
-        return Feature(layer=sync_layer, srid=self.srid, data=self.data)
+        Example:
+            >>> from geobox.aio import AsyncGeoboxClient
+            >>> async with AsyncGeoboxClient() as client:
+            >>>     layer = await client.get_vector(uuid="12345678-1234-5678-1234-567812345678")
+            >>>     feature = await layer.get_feature(feature_id=1)
+            >>>     await feature.associate_with(
+            ...         relationship_uuid="12345678-1234-5678-1234-567812345678",
+            ...         target_ids=[1, 2, 3],
+            ...     )
+        """
+        relationship = await self.api.get_relationship(uuid=relationship_uuid)
+        return await relationship.associate_records(
+            source_id=self.id,
+            target_ids=target_ids,
+            q=q,
+        )
+
+
+    async def disassociate_with(
+        self,
+        relationship_uuid: str,
+        *,
+        target_ids: Optional[List[int]] = None,
+        q: Optional[str] = None,
+    ) -> Dict:
+        """
+        [async] Remove relationships between the source record and target records
+
+        Args:
+            relationship_uuid (str): the relationship uuid
+            target_ids (List[int], optional): a list of target record ids to be disassociated with the current record
+            q (str, optional): query filter on target layer or table to select which target features or rows that are going to be related to the current record
+
+        Returns:
+            Dict: the record association result
+
+        Example:
+            >>> from geobox.aio import AsyncGeoboxClient
+            >>> async with AsyncGeoboxClient() as client:
+            >>>     layer = await client.get_vector(uuid="12345678-1234-5678-1234-567812345678")
+            >>>     feature = await layer.get_feature(feature_id=1)
+            >>>     await feature.disassociate_with(
+            ...         relationship_uuid="12345678-1234-5678-1234-567812345678",
+            ...         target_ids=[1, 2, 3],
+            ...     )
+        """
+        relationship = await self.api.get_relationship(uuid=relationship_uuid)
+        return await relationship.disassociate_records(
+            source_id=self.id,
+            target_ids=target_ids,
+            q=q,
+        )

geobox/aio/field.py

@@ -8,8 +8,6 @@ from ..enums import FieldType
 if TYPE_CHECKING:
     from .api import AsyncGeoboxClient
     from .vectorlayer import VectorLayer
-    from ..api import GeoboxClient
-    from ..field import Field
 
 
 class AsyncField(AsyncBase):
@@ -288,28 +286,3 @@ class AsyncField(AsyncBase):
 
         await self.save()
         return self.domain
-
-
-    def to_sync(self, sync_client: 'GeoboxClient') -> 'Field':
-        """
-        Switch to sync version of the field instance to have access to the sync methods
-
-        Args:
-            sync_client (GeoboxClient): The sync version of the GeoboxClient instance for making requests.
-
-        Returns:
-            Field: the sync instance of the field.
-
-        Example:
-            >>> from geobox import Geoboxclient
-            >>> from geobox.aio import AsyncGeoboxClient
-            >>> client = GeoboxClient()
-            >>> async with AsyncGeoboxClient() as async_client:
-            >>>     layer = await async_client.get_vector(uuid="12345678-1234-5678-1234-567812345678")
-            >>>     field = await layer.get_field(name='test')
-            >>>     sync_field = field.to_sync(client)
-        """
-        from ..field import Field
-
-        sync_layer = self.layer.to_sync(sync_client=sync_client)
-        return Field(layer=sync_layer, data_type=self.data_type, field_id=self.field_id, data=self.data)

geobox/aio/file.py

@@ -16,8 +16,6 @@ from ..exception import ApiRequestError
 if TYPE_CHECKING:
     from . import AsyncGeoboxClient 
     from .user import AsyncUser
-    from ..api import GeoboxClient
-    from ..file import File
 
 
 class AsyncFile(AsyncBase):
@@ -496,27 +494,3 @@ class AsyncFile(AsyncBase):
             'limit': limit
         }
         return await super()._get_shared_users(self.endpoint, params)
-
-
-    def to_sync(self, sync_client: 'GeoboxClient') -> 'File':
-        """
-        Switch to sync version of the file instance to have access to the sync methods
-
-        Args:
-            sync_client (GeoboxClient): The sync version of the GeoboxClient instance for making requests.
-
-        Returns:
-            File: the async instance of the file.
-
-        Example:
-            >>> from geobox import Geoboxclient
-            >>> from geobox.aio import AsyncGeoboxClient
-            >>> from geobox.aio.file import AsyncFile
-            >>> client = GeoboxClient()
-            >>> async with AsyncGeoboxClient() as async_client:
-            >>>     file = await AsyncFile.get_file(async_client, uuid="12345678-1234-5678-1234-567812345678")
-            >>>     sync_file = file.to_sync(client)
-        """
-        from ..file import File
-
-        return File(api=sync_client, uuid=self.uuid, data=self.data)

geobox/aio/layout.py

@@ -5,8 +5,6 @@ from .base import AsyncBase
 if TYPE_CHECKING:
     from . import AsyncGeoboxClient
     from .user import AsyncUser
-    from ..api import GeoboxClient
-    from ..layout import Layout
 
 
 class AsyncLayout(AsyncBase):
@@ -314,27 +312,3 @@ class AsyncLayout(AsyncBase):
             'limit': limit
         }
         return await super()._get_shared_users(self.endpoint, params)
-
-
-    def to_sync(self, sync_client: 'GeoboxClient') -> 'Layout':
-        """
-        Switch to sync version of the layout instance to have access to the sync methods
-
-        Args:
-            sync_client (GeoboxClient): The sync version of the GeoboxClient instance for making requests.
-
-        Returns:
-            Layout: the sync instance of the layout.
-
-        Example:
-            >>> from geobox import Geoboxclient
-            >>> from geobox.aio import AsyncGeoboxClient
-            >>> from geobox.aio.layout import AsyncLayout
-            >>> client = GeoboxClient()
-            >>> async with AsyncGeoboxClient() as async_client:
-            >>>     layout = await AsyncLayout.get_layout(async_client, uuid="12345678-1234-5678-1234-567812345678")
-            >>>     sync_layout = layout.to_sync(client)
-        """
-        from ..layout import Layout
-
-        return Layout(api=sync_client, uuid=self.uuid, data=self.data)

geobox/aio/log.py

@@ -5,8 +5,6 @@ from .base import AsyncBase
 if TYPE_CHECKING:
     from . import AsyncGeoboxClient
     from .user import AsyncUser
-    from ..api import GeoboxClient
-    from ..log import Log
 
 
 class AsyncLog(AsyncBase):
@@ -118,28 +116,3 @@ class AsyncLog(AsyncBase):
             >>>     await log.user
         """
         return await self.api.get_user(self.owner_id)
-
-
-    def to_sync(self, sync_client: 'GeoboxClient') -> 'Log':
-        """
-        Switch to sync version of the log instance to have access to the sync methods
-
-        Args:
-            sync_client (GeoboxClient): The sync version of the GeoboxClient instance for making requests.
-
-        Returns:
-            Log: the sync instance of the log.
-
-        Example:
-            >>> from geobox import Geoboxclient
-            >>> from geobox.aio import AsyncGeoboxClient
-            >>> from geopox.aio.log import AsyncLog
-            >>> client = GeoboxClient()
-            >>> async with AsyncGeoboxClient() as async_client:
-            >>>     logs = await AsyncLog.get_logs(async_client)
-            >>>     log = logs[0]
-            >>>     sync_log = log.to_sync(client)
-        """
-        from ..log import Log
-
-        return Log(api=sync_client, log_id=self.log_id, data=self.data)

geobox/aio/map.py

@@ -12,8 +12,6 @@ if TYPE_CHECKING:
     from .user import AsyncUser
     from .task import AsyncTask
     from .attachment import AsyncAttachment
-    from ..api import GeoboxClient
-    from ..map import Map
 
 
 class AsyncMap(AsyncBase):
@@ -1007,27 +1005,3 @@ class AsyncMap(AsyncBase):
             feature=feature,
             display_name=display_name,
             description=description)
-
-
-    def to_sync(self, sync_client: 'GeoboxClient') -> 'Map':
-        """
-        Switch to sync version of the map instance to have access to the sync methods
-
-        Args:
-            sync_client (GeoboxClient): The sync version of the GeoboxClient instance for making requests.
-
-        Returns:
-            Map: the sync instance of the map.
-
-        Example:
-            >>> from geobox import Geoboxclient
-            >>> from geobox.aio import AsyncGeoboxClient
-            >>> from geobox.aio.map import AsyncMap
-            >>> client = GeoboxClient()
-            >>> async with AsyncGeoboxClient() as async_client:
-            >>>     map = await AsyncMap.get_map(async_client, uuid="12345678-1234-5678-1234-567812345678")
-            >>>     sync_map = map.to_sync(client)
-        """
-        from ..map import Map
-
-        return Map(api=sync_client, uuid=self.uuid, data=self.data)

geobox/aio/model3d.py

@@ -11,8 +11,6 @@ from ..utils import get_save_path
 if TYPE_CHECKING:
     from . import AsyncGeoboxClient
     from .user import AsyncUser
-    from ..api import GeoboxClient
-    from ..model3d import Model
 
 
 class AsyncModel(AsyncBase):
@@ -389,27 +387,3 @@ class AsyncModel(AsyncBase):
             'limit': limit
         }
         return await super()._get_shared_users(self.endpoint, params)
-
-
-    def to_sync(self, sync_client: 'GeoboxClient') -> 'Model':
-        """
-        Switch to sync version of the 3d model instance to have access to the sync methods
-
-        Args:
-            sync_client (GeoboxClient): The sync version of the GeoboxClient instance for making requests.
-
-        Returns:
-            Model: the sync instance of the 3d model.
-
-        Example:
-            >>> from geobox import Geoboxclient
-            >>> from geobox.aio import AsyncGeoboxClient
-            >>> from geobox.aio.model3d import AsyncModel
-            >>> client = GeoboxClient()
-            >>> async with AsyncGeoboxClient() as async_client:
-            >>>     model = await AsyncModel.get_model(async_client, uuid="12345678-1234-5678-1234-567812345678")
-            >>>     sync_model = model.to_sync(client)
-        """
-        from ..model3d import Model
-
-        return Model(api=sync_client, uuid=self.uuid, data=self.data)

geobox/aio/mosaic.py

@@ -8,8 +8,6 @@ if TYPE_CHECKING:
     from . import AsyncGeoboxClient
     from .user import AsyncUser
     from .task import AsyncTask
-    from ..api import GeoboxClient
-    from ..mosaic import Mosaic
 
 
 class AsyncMosaic(AsyncRaster):
@@ -670,27 +668,3 @@ class AsyncMosaic(AsyncRaster):
             >>>     await mosaic.cache_size
         """
         return await super().cache_size
-
-
-    def to_sync(self, sync_client: 'GeoboxClient') -> 'Mosaic':
-        """
-        Switch to sync version of the mosaic instance to have access to the sync methods
-
-        Args:
-            sync_client (GeoboxClient): The sync version of the GeoboxClient instance for making requests.
-
-        Returns:
-            Mosiac: the sync instance of the mosaic.
-
-        Example:
-            >>> from geobox import Geoboxclient
-            >>> from geobox.aio import AsyncGeoboxClient
-            >>> from geobox.aio.mosaic import AsyncMosaic
-            >>> client = GeoboxClient()
-            >>> async with AsyncGeoboxClient() as async_client:
-            >>>     mosaic = await AsyncMosaic.get_mosaic(async_client, uuid="12345678-1234-5678-1234-567812345678")
-            >>>     sync_mosaic = mosaic.to_sync(client)
-        """
-        from ..mosaic import Mosaic
-
-        return Mosaic(api=sync_client, uuid=self.uuid, data=self.data)

geobox/aio/plan.py

@@ -5,8 +5,6 @@ from .base import AsyncBase
 
 if TYPE_CHECKING:
     from . import AsyncGeoboxClient
-    from ..api import GeoboxClient
-    from ..plan import Plan
 
 
 class AsyncPlan(AsyncBase):
@@ -289,27 +287,3 @@ class AsyncPlan(AsyncBase):
         """
         await super()._delete(self.endpoint)
         self.plan_id = None
-
-
-    def to_sync(self, sync_client: 'GeoboxClient') -> 'Plan':
-        """
-        Switch to sync version of the plan instance to have access to the sync methods
-
-        Args:
-            sync_client (GeoboxClient): The sync version of the GeoboxClient instance for making requests.
-
-        Returns:
-            Plan: the sync instance of the plan.
-
-        Example:
-            >>> from geobox import Geoboxclient
-            >>> from geobox.aio import AsyncGeoboxClient
-            >>> from geobox.aio.plan import AsyncPlan
-            >>> client = GeoboxClient()
-            >>> async with AsyncGeoboxClient() as async_client:
-            >>>     plan = await AsyncPlan.get_plan(async_client, plan_id=1)
-            >>>     sync_plan = plan.to_sync(client)
-        """
-        from ..plan import Plan as SyncPlan
-
-        return SyncPlan(api=sync_client, plan_id=self.plan_id, data=self.data)

geobox/aio/query.py

@@ -9,8 +9,6 @@ from ..enums import QueryResultType, QueryGeometryType, QueryParamType
 if TYPE_CHECKING:
     from . import AsyncGeoboxClient
     from .user import AsyncUser
-    from ..api import GeoboxClient
-    from ..query import Query
 
 
 class AsyncQuery(AsyncBase):
@@ -667,27 +665,3 @@ class AsyncQuery(AsyncBase):
         response = await self.api.post(endpoint, data)
         task = await AsyncTask.get_task(self.api, response.get('task_id'))
         return task
-
-
-    def to_sync(self, sync_client: 'GeoboxClient') -> 'Query':
-        """
-        Switch to sync version of the query instance to have access to the sync methods
-
-        Args:
-            sync_client (GeoboxClient): The sync version of the GeoboxClient instance for making requests.
-
-        Returns:
-            Query: the sync instance of the query.
-
-        Example:
-            >>> from geobox import Geoboxclient
-            >>> from geobox.aio import AsyncGeoboxClient
-            >>> from geobox.aio.query import AsyncQuery
-            >>> client = GeoboxClient()
-            >>> async with AsyncGeoboxClient() as async_client:
-            >>>     query = await AsyncQuery.get_query(async_client, uuid="12345678-1234-5678-1234-567812345678")
-            >>>     sync_query = query.to_sync(client)
-        """
-        from ..query import Query
-
-        return Query(api=sync_client, uuid=self.uuid, data=self.data)

geobox/aio/raster.py

@@ -12,8 +12,6 @@ from ..utils import clean_data, join_url_params
 if TYPE_CHECKING:
     from . import AsyncGeoboxClient
     from .user import AsyncUser
-    from ..api import GeoboxClient
-    from ..raster import Raster
 
 
 class AsyncRaster(AsyncBase):
@@ -844,30 +842,6 @@ class AsyncRaster(AsyncBase):
         return await super()._cache_size(self.endpoint)
 
 
-    def to_sync(self, sync_client: 'GeoboxClient') -> 'Raster':
-        """
-        Switch to sync version of the raster instance to have access to the sync methods
-
-        Args:
-            sync_client (GeoboxClient): The sync version of the GeoboxClient instance for making requests.
-
-        Returns:
-            Raster: the sync instance of the raster.
-
-        Example:
-            >>> from geobox import Geoboxclient
-            >>> from geobox.aio import AsyncGeoboxClient
-            >>> from geobox.aio.raster import AsyncRaster
-            >>> client = GeoboxClient()
-            >>> async with AsyncGeoboxClient() as async_client:
-            >>>     raster = await AsyncRaster.get_raster(async_client, uuid="12345678-1234-5678-1234-567812345678")
-            >>>     sync_raster = raster.to_sync(client)
-        """
-        from ..raster import Raster
-
-        return Raster(api=sync_client, uuid=self.uuid, data=self.data)
-
-
     async def profile(self,
         polyline: List,
         number_of_samples: int = 100,

geobox/aio/scene.py

@@ -5,8 +5,7 @@ from .base import AsyncBase
 if TYPE_CHECKING:
     from . import AsyncGeoboxClient
     from .user import AsyncUser
-    from ..api import GeoboxClient
-    from ..scene import Scene
+
 
 class AsyncScene(AsyncBase):
 
@@ -314,27 +313,3 @@ class AsyncScene(AsyncBase):
             'limit': limit
         }
         return await super()._get_shared_users(self.endpoint, params)
-
-
-    def to_sync(self, sync_client: 'GeoboxClient') -> 'Scene':
-        """
-        Switch to sync version of the scene instance to have access to the sync methods
-
-        Args:
-            sync_client (GeoboxClient): The sync version of the GeoboxClient instance for making requests.
-
-        Returns:
-            Scene: the sync instance of the scene.
-
-        Example:
-            >>> from geobox import Geoboxclient
-            >>> from geobox.aio import AsyncGeoboxClient
-            >>> from geobox.aio.scene import AsyncScene
-            >>> client = GeoboxClient()
-            >>> async with AsyncGeoboxClient() as async_client:
-            >>>     scene = await AsyncScene.get_scene(async_client, uuid="12345678-1234-5678-1234-567812345678")
-            >>>     sync_scene = scene.to_sync(client)
-        """
-        from ..scene import Scene
-
-        return Scene(api=sync_client, uuid=self.uuid, data=self.data)

geobox/aio/settings.py

@@ -7,8 +7,6 @@ from ..enums import MaxLogPolicy, InvalidDataPolicy, LoginFailurePolicy, MaxConc
 
 if TYPE_CHECKING:
     from . import AsyncGeoboxClient
-    from ..api import GeoboxClient
-    from ..settings import SystemSettings
 
 
 class AsyncSystemSettings(AsyncBase):
@@ -166,29 +164,3 @@ class AsyncSystemSettings(AsyncBase):
             
         }
         return await super()._update(self.BASE_ENDPOINT, data)
-
-
-    def to_sync(self, sync_client: 'GeoboxClient') -> 'SystemSettings':
-        """
-        Switch to sync version of the system settings instance to have access to the sync methods
-
-        Args:
-            sync_client (GeoboxClient): The sync version of the GeoboxClient instance for making requests.
-
-        Returns:
-            SystemSettings: the sync instance of the system settings.
-
-        Example:
-            >>> from geobox import Geoboxclient
-            >>> from geobox.aio import AsyncGeoboxClient
-            >>> from geobox.aio.setting import AsyncSystemSettings
-            >>> client = GeoboxClient()
-            >>> async with AsyncGeoboxClient() as async_client:
-            >>>     settings = await AsyncSystemSetting.get_system_settings(async_client)
-            or  
-            >>>     settings = await async_client.get_system_settings()
-            >>>     sync_settings = settings.to_sync(client)
-        """
-        from ..task import Task as SyncTask
-
-        return SyncTask(api=sync_client, uuid=self.uuid, data=self.data)