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

geobox/aio/api.py

@@ -3,7 +3,7 @@ import asyncio
 import logging
 import os
 from urllib.parse import urljoin
-from typing import Dict, List, Union, Any
+from typing import Dict, List, Union, Any, Optional
 from datetime import datetime
 
 from .vectorlayer import AsyncVectorLayer, LayerType
@@ -32,6 +32,7 @@ from .attachment import AsyncAttachment
 from .apikey import AsyncApiKey
 from .log import AsyncLog
 from .usage import AsyncUsage, UsageScale, UsageParam
+from .table import AsyncTable, AsyncRelationship, RelationshipCardinality, RelationshipEndpoint
 from ..exception import AuthenticationError, ApiRequestError, NotFoundError, ValidationError, ServerError, AuthorizationError
 from ..utils import join_url_params
 
@@ -129,11 +130,10 @@ class AsyncGeoboxClient:
         """
         Constructs all the necessary attributes for the Api object.
         """
-        self.username = os.getenv('GEOBOX_USERNAME') if os.getenv('GEOBOX_USERNAME') else username
-        self.password = os.getenv('GEOBOX_PASSWORD') if os.getenv('GEOBOX_PASSWORD') else password
-        self.access_token = os.getenv('GEOBOX_ACCESS_TOKEN') if os.getenv('GEOBOX_ACCESS_TOKEN') else access_token
-        self.apikey = os.getenv('GEOBOX_APIKEY') if os.getenv('GEOBOX_APIKEY') else apikey
-
+        self.username = username if username else os.getenv('GEOBOX_USERNAME')
+        self.password = password if password else os.getenv('GEOBOX_PASSWORD')
+        self.access_token = access_token if access_token else os.getenv('GEOBOX_ACCESS_TOKEN')
+        self.apikey = apikey if apikey else os.getenv('GEOBOX_APIKEY')
         self.session = AsyncRequestSession(access_token=self.access_token)
 
         host = host.lower()
@@ -2654,3 +2654,262 @@ class AsyncGeoboxClient:
             >>>     await client.update_usage()
         """
         return await AsyncUsage.update_usage(self, user_id=user_id)
+
+
+    async def get_tables(self, **kwargs) -> Union[List['AsyncTable'], int]:
+        """
+        [async] Get list of tables with optional filtering and pagination.
+
+        Keyword Args:
+            include_settings (bool): Whether to include table settings. default: False
+            temporary (bool): Whether to return temporary tables. default: False
+            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: False.
+            skip (int): Number of items to skip. default: 0
+            limit (int): Number of items to return. default: 10
+            user_id (int): Specific user. privileges required
+            shared (bool): Whether to return shared tables. default: False
+
+        Returns:
+            List[AsyncTable] | int: A list of table instances or the total number of tables.
+
+        Example:
+            >>> from geobox.aio import AsyncGeoboxClient
+            >>> async with AsyncGeoboxClient() as client:
+            >>>     tables = await client.get_tables(q="name LIKE '%My table%'")
+        """
+        return await AsyncTable.get_tables(self, **kwargs)
+    
+
+    async def create_table(self,
+        name: str, 
+        display_name: Optional[str] = None, 
+        description: Optional[str] = None, 
+        temporary: bool = False,
+        fields: Optional[List[Dict]] = None,
+    ) -> 'AsyncTable':
+        """
+        [async] Create a new table.
+
+        Args:
+            name (str): The name of the Table.
+            display_name (str, optional): The display name of the table.
+            description (str, optional): The description of the table.
+            temporary (bool, optional): Whether to create a temporary tables. default: False
+            fields (List[Dict], optional): raw table fields. you can use add_field method for simpler and safer field addition. required dictionary keys: name, datatype
+
+        Returns:
+            AsyncTable: The newly created table instance.
+
+        Raises:
+            ValidationError: If the table data is invalid.
+
+        Example:
+            >>> from geobox.aio import AsyncGeoboxClient
+            >>> async with AsyncGeoboxClient() as client:
+            >>>     table = await client.create_table(name="my_table")
+        """
+        return await AsyncTable.create_table(self,
+            name=name,
+            display_name=display_name,
+            description=description,
+            temporary=temporary,
+            fields=fields,
+        )
+    
+
+    async def get_table(self, 
+        uuid: str, 
+        user_id: int = None,
+    ) -> 'AsyncTable':
+        """
+        [async] Get a table by UUID.
+
+        Args:
+            uuid (str): The UUID of the table to get.
+            user_id (int): Specific user. privileges required.
+
+        Returns:
+            AsyncTable: The Table object.
+
+        Raises:
+            NotFoundError: If the table with the specified UUID is not found.
+
+        Example:
+            >>> from geobox.aio import AsyncGeoboxClient
+            >>> async with AsyncGeoboxClient() as client:
+            >>>     table = await client.get_table(uuid="12345678-1234-5678-1234-567812345678")
+        """
+        return await AsyncTable.get_table(self, uuid, user_id)
+
+
+    async def get_table_by_name(self, 
+        name: str, 
+        user_id: int = None,
+    ) -> Union['AsyncTable', None]:
+        """
+        [async] Get a table by name
+
+        Args:
+            name (str): the name of the table to get
+            user_id (int, optional): specific user. privileges required.
+
+        Returns:
+            AsyncTable | None: returns the table if a table matches the given name, else None
+
+        Example:
+            >>> from geobox.aio import AsybcGeoboxClient
+            >>> async with AsyncGeoboxClient() as client:
+            >>>     table = await client.get_table_by_name(name='test')
+        """
+        return await AsyncTable.get_table_by_name(self, name, user_id)
+
+
+    async def get_relationships(
+        self,
+        **kwargs,
+    ) -> Union[List['AsyncRelationship'], int]:
+        """
+        [async] Get a list of relationships 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: False.
+            skip (int): Number of items to skip. default: 0
+            limit (int): Number of items to return. default: 10
+            user_id (int): Specific user. privileges required
+            shared (bool): Whether to return shared tables. default: False
+
+        Returns:
+            List[AsyncRelationship] | int: A list of relationship instances or the total number of relationships.
+
+        Example:
+            >>> from geobox.aio import AsyncGeoboxClient
+            >>> async with AsyncGeoboxClient() as client:
+            >>>     relationships = await client.get_relationships(q="name LIKE '%My relationship%'")
+        """
+        return await AsyncRelationship.get_relationships(self, **kwargs)
+
+
+    async def create_relationship(
+        self,
+        name: str,
+        cardinality: 'RelationshipCardinality',
+        *,
+        source: 'RelationshipEndpoint',
+        target: 'RelationshipEndpoint',
+        relation_table: Optional['AsyncTable'] = None,
+        display_name: Optional[str] = None,
+        description: Optional[str] = None,
+        user_id: Optional[int] = None,
+    ) -> 'AsyncRelationship':
+        """
+        [async] Create a new AsyncRelationship
+
+        Args:
+            name (str): name of the relationship
+            cardinality (RelationshipCardinality): One to One, One to Many, or Many to Many
+            
+        Keyword Args:
+            source (RelationshipEndpoint): Definition of the source side of the relationship, including the table (or layer), field, and foreign-key field
+            target (RelationshipEndpoint): Definition of the target side of the relationship, including the table (or layer), field, and foreign-key field
+            relation_table (AsyncTable, optional): The table that stores the relationship metadata or join records. (Required for Many-to-Many relationships)
+            display_name (str, optional): Human-readable name for the relationship
+            description (str, optional): the description of the relationship
+            user_id (int, optional): Specific user. privileges required.
+
+        Returns:
+            AsyncRelationship: a relationship instance
+
+        Example:
+            >>> from geobox.aio import AsyncGeoboxClient
+            >>> from geobox.aio.table import RelationshipEndpoint, RelationshipCardinality
+            >>> async with AsyncGeoboxClient() as client:
+            >>>     source = RelationshipEndpoint(
+            ...         table=client.get_table_by_name('owner'),
+            ...         field="name", # on source table
+            ...         fk_field="book_name", # on relation table
+            ...     )
+            >>>     target = RelationshipEndpoint(
+            ...         table=client.get_table_by_name('parcel'),
+            ...         field="name", # on target table
+            ...         fk_field="author_name", # on relation table
+            ...     )
+            >>>     relationship = await client.create_relationship(
+            ...         name="owner_parcel",
+            ...         cardinality=RelationshipCardinality.ManytoMany,
+            ...         source=source,
+            ...         target=target,
+            ...         relation_table=client.get_table_by_name('owner_parcel'),
+            ...     )
+        """
+        return await AsyncRelationship.create_relationship(
+            self,
+            name=name,
+            cardinality=cardinality,
+            source=source,
+            target=target,
+            relation_table=relation_table,
+            display_name=display_name,
+            description=description,
+            user_id=user_id,
+        )
+
+
+    async def get_relationship(
+        self,
+        uuid: str,
+        user_id: Optional[int] = None,
+    ) -> 'AsyncRelationship':
+        """
+        [async] Get a relationship by UUID.
+
+        Args:
+            uuid (str): The UUID of the relationship to get.
+            user_id (int, optional): Specific user. privileges required.
+
+        Returns:
+            AsyncRelationship: The AsyncRelationship object.
+
+        Raises:
+            NotFoundError: If the AsyncRelationship with the specified UUID is not found.
+
+        Example:
+            >>> from geobox.aio import AsyncGeoboxClient
+            >>> async with AsyncGeoboxClient() as client:
+            >>>     relationship = await client.get_relationship(uuid="12345678-1234-5678-1234-567812345678")
+        """
+        return await AsyncRelationship.get_relationship(
+            self,
+            uuid=uuid,
+            user_id=user_id,
+        )
+
+
+    async def get_relationship_by_name(
+        self, 
+        name: str, 
+        user_id: Optional[int] = None,
+    ) -> Union['AsyncRelationship', None]:
+        """
+        [async] Get a relationship by name
+
+        Args:
+            name (str): the name of the relationship to get
+            user_id (int, optional): specific user. privileges required.
+
+        Returns:
+            AsyncRelationship | None: returns the relationship if a relationship matches the given name, else None
+
+        Example:
+            >>> from geobox.aio import AsyncGeoboxClient
+            >>> async with AsyncGeoboxClient() as client:
+            >>>     relationship = await client.get_relationship_by_name(name='test')
+        """
+        return await AsyncRelationship.get_relationship_by_name(self, name=name, user_id=user_id)

geobox/aio/apikey.py

@@ -6,8 +6,6 @@ from ..utils import clean_data
 
 if TYPE_CHECKING:
     from . import AsyncGeoboxClient
-    from ..api import GeoboxClient
-    from ..apikey import ApiKey
 
 
 class AsyncApiKey(AsyncBase):
@@ -237,27 +235,3 @@ class AsyncApiKey(AsyncBase):
         endpoint = f"{self.endpoint}/grant"
         await self.api.post(endpoint)
         self.data['revoked'] = False
-
-
-    def to_sync(self, sync_client: 'GeoboxClient') -> 'ApiKey':
-        """
-        Switch to sync version of the apikey instance to have access to the sync methods
-
-        Args:
-            sync_client (GeoboxClient): The sync version of the GeoboxClient instance for making requests.
-
-        Returns:
-            ApiKey: the sync instance of the apikey.
-
-        Example:
-            >>> from geobox import Geoboxclient
-            >>> from geobox.aio import AsyncGeoboxClient
-            >>> from geobox.aio.apikey import AsyncApiKey
-            >>> client = GeoboxClient()
-            >>> async with AsyncGeoboxClient() as async_client:
-            >>>     apikey = await AsyncApiKey.get_apikey(async_client, key_id=1)
-            >>>     sync_apikey = apikey.to_sync(client)
-        """
-        from ..apikey import ApiKey
-
-        return ApiKey(api=sync_client, key_id=self.key_id, data=self.data)

geobox/aio/attachment.py

@@ -10,9 +10,7 @@ from ..utils import clean_data
 
 if TYPE_CHECKING:
     from . import AsyncGeoboxClient 
-    from .feature import Feature
-    from ..api import GeoboxClient
-    from ..attachment import Attachment
+    from .feature import AsyncFeature
 
 
 class AsyncAttachment(AsyncBase):
@@ -126,8 +124,8 @@ class AsyncAttachment(AsyncBase):
         loc_x: int,
         loc_y: int,
         resource: Union['AsyncMap', 'AsyncVectorLayer', 'AsyncVectorLayerView'],
-        file: 'File',
-        feature: 'Feature' = None,
+        file: 'AsyncFile',
+        feature: 'AsyncFeature' = None,
         display_name: str = None, 
         description: str = None, ) -> 'AsyncAttachment':
         """
@@ -139,8 +137,8 @@ class AsyncAttachment(AsyncBase):
             loc_x (int): x parameter of the attachment location.
             loc_y (int): y parameter of the attachment location.
             resource (AsyncMap | AsyncVectorLayer | AsyncVectorLayerView): the resource object.
-            file (File): the file object.
-            feature (Feature, optional): the feature object.
+            file (AsyncFile): the file object.
+            feature (AsyncFeature, optional): the feature object.
             display_name (str, optional): The display name of the scene.
             description (str, optional): The description of the scene.
 
@@ -315,27 +313,3 @@ class AsyncAttachment(AsyncBase):
             >>>     attachment.thumbnail
         """
         return super()._thumbnail(format='')
-    
-
-    def to_sync(self, sync_client: 'GeoboxClient') -> 'Attachment':
-        """
-        Switch to sync version of the attachment instance to have access to the sync methods
-
-        Args:
-            sync_client (GeoboxClient): The sync version of the GeoboxClient instance for making requests.
-
-        Returns:
-            Attachment: the sync instance of the attachment.
-
-        Example:
-            >>> from geobox import Geoboxclient
-            >>> from geobox.aio import AsyncGeoboxClient
-            >>> from geobox.aio.attachment import AsyncAttachment
-            >>> client = GeoboxClient()
-            >>> async with AsyncGeoboxClient() as async_client:
-            >>>     attachment = await AsyncAttachment.get_attachment(async_client, uuid="12345678-1234-5678-1234-567812345678")
-            >>>     sync_attachment = attachment.to_sync(client)
-        """
-        from ..attachment import Attachment
-
-        return Attachment(api=sync_client, attachment_id=self.attachment_id, data=self.data)

geobox/aio/basemap.py

@@ -7,8 +7,6 @@ from ..utils import clean_data
 
 if TYPE_CHECKING:
     from . import AsyncGeoboxClient
-    from ..api import GeoboxClient
-    from ..basemap import Basemap
 
 
 class AsyncBasemap(AsyncBase):
@@ -143,12 +141,12 @@ class AsyncBasemap(AsyncBase):
     
 
     @classmethod
-    async def proxy_basemap(cls, api: 'response', url: str) -> None:
+    async def proxy_basemap(cls, api: 'AsyncGeoboxClient', url: str) -> None:
         """
         [async] Proxy the basemap
 
         Args:
-            api (GeoboxClient): The GeoboxClient instance for making requests.
+            api (AsyncGeoboxClient): The GeoboxClient instance for making requests.
             url (str): the proxy server url.
 
         Returns:
@@ -168,29 +166,3 @@ class AsyncBasemap(AsyncBase):
         query_string = urlencode(param)
         endpoint = urljoin(cls.BASE_ENDPOINT, f"?{query_string}")
         await api.get(endpoint)
-
-
-    def to_sync(self, sync_client: 'GeoboxClient') -> 'Basemap':
-        """
-        Switch to sync version of the basemap instance to have access to the sync methods
-
-        Args:
-            sync_client (GeoboxClient): The sync version of the GeoboxClient instance for making requests.
-
-        Returns:
-            Basemap: the sync instance of the basemap.
-
-        Example:
-            >>> from geobox import Geoboxclient
-            >>> from geobox.aio import AsyncGeoboxClient
-            >>> from geobox.aio.basemap import AsyncBasemap
-            >>> client = GeoboxClient()
-            >>> async with AsyncGeoboxClient() as async_client:
-            >>>     basemap = await AsyncBasemap.get_basemap(async_client, name='test')
-            or  
-            >>>     basemap = await async_client.get_basemap(name='test')
-            >>>     sync_basemap = basemap.to_sync(client)
-        """
-        from ..basemap import Basemap
-
-        return Basemap(api=sync_client, data=self.data)

geobox/aio/dashboard.py

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