geobox 2.2.5__py3-none-any.whl → 2.3.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
 from ..exception import AuthenticationError, ApiRequestError, NotFoundError, ValidationError, ServerError, AuthorizationError
 from ..utils import join_url_params
 
@@ -2654,3 +2655,115 @@ 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)