geobox 2.2.5__py3-none-any.whl → 2.3.0__py3-none-any.whl

geobox/api.py

@@ -35,6 +35,7 @@ from .attachment import Attachment
 from .apikey import ApiKey
 from .log import Log
 from .usage import Usage, UsageScale, UsageParam
+from .table import Table
 
 logger = logging.getLogger(__name__)
 
@@ -109,7 +110,7 @@ class _RequestSession(requests.Session):
             
         return original_content_type
             
-    def request(self, method: str, url: str, **kwargs) -> requests.Response:
+    def request(self, method: str, url: str, verify: bool = True, **kwargs) -> requests.Response:
         """
         Override request method with header management.
         
@@ -136,7 +137,7 @@ class _RequestSession(requests.Session):
         kwargs['headers'] = request_headers
         
         try:
-            response = super().request(method, url, **kwargs)
+            response = super().request(method, url, verify=verify, **kwargs)
         finally:
             if original_content_type:
                 self.headers['Content-Type'] = original_content_type
@@ -150,12 +151,14 @@ class GeoboxClient:
     """
 
     def __init__(self,
-                host: str = 'https://api.geobox.ir',
-                ver: str = 'v1/',
-                username: str = None,
-                password: str = None,
-                access_token: str = None, 
-                apikey: str = None):
+        host: str = 'https://api.geobox.ir',
+        ver: str = 'v1/',
+        username: str = None,
+        password: str = None,
+        access_token: str = None, 
+        apikey: str = None,
+        verify: bool = True,
+    ):
         """
         Constructs all the necessary attributes for the Api object.
 
@@ -175,6 +178,7 @@ class GeoboxClient:
             password (str, optional): Password for authentication
             access_token (str, optional): Bearer token for authentication
             apikey (str, optional): API key for authentication
+            verify (bool, optional): it controls whether to verify the server's TLS certificate. Defaults to True. When set to False, requests will accept any TLS certificate presented by the server, and will ignore hostname mismatches and/or expired certificates, which will make your application vulnerable to man-in-the-middle (MitM) attacks. Setting verify to False may be useful during local development or testing
 
         Example:
             >>> from geobox import GeoboxClient
@@ -188,7 +192,7 @@ class GeoboxClient:
         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.verify = verify
         self.session = _RequestSession(access_token=self.access_token)
 
         host = host.lower()
@@ -232,7 +236,7 @@ class GeoboxClient:
         url = urljoin(self.base_url, "auth/token/")
         data = {"username": self.username, "password": self.password}
         try:
-            response = requests.post(url, data=data)
+            response = requests.post(url, data=data, verify=self.verify)
             response_data = response.json()     
             if response.status_code == 200:
                 return response_data["access_token"]
@@ -328,11 +332,11 @@ class GeoboxClient:
 
         try:
             if files:
-                response = self.session.request(method, url, data=payload, files=files)
+                response = self.session.request(method, url, verify=self.verify, data=payload, files=files)
             elif is_json:
-                response = self.session.request(method, url, json=payload)
+                response = self.session.request(method, url, verify=self.verify, json=payload)
             else:
-                response = self.session.request(method, url, data=payload)
+                response = self.session.request(method, url, verify=self.verify, data=payload)
                 
         except requests.exceptions.Timeout as e:
             raise ApiRequestError(f"Request timed out: {e}")
@@ -2635,3 +2639,117 @@ class GeoboxClient:
             >>> client.update_usage()
         """
         return Usage.update_usage(self, user_id=user_id)
+
+
+
+    def get_tables(self, **kwargs) -> Union[List['Table'], int]:
+        """
+        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[Table] | int: A list of table instances or the total number of tables.
+
+        Example:
+            >>> from geobox import GeoboxClient
+            >>> client = GeoboxClient()
+            >>> tables = client.get_tables(q="name LIKE '%My table%'")
+        """
+        return Table.get_tables(self, **kwargs)
+    
+
+    def create_table(self,
+        name: str, 
+        display_name: Optional[str] = None, 
+        description: Optional[str] = None, 
+        temporary: bool = False,
+        fields: Optional[List[Dict]] = None,
+    ) -> 'Table':
+        """
+        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:
+            Table: The newly created table instance.
+
+        Raises:
+            ValidationError: If the table data is invalid.
+
+        Example:
+            >>> from geobox import GeoboxClient
+            >>> client = GeoboxClient()
+            >>> table = client.create_table(name="my_table")
+        """
+        return Table.create_table(self,
+            name=name,
+            display_name=display_name,
+            description=description,
+            temporary=temporary,
+            fields=fields,
+        )
+    
+
+    def get_table(self, 
+        uuid: str, 
+        user_id: int = None,
+    ) -> 'Table':
+        """
+        Get a table by UUID.
+
+        Args:
+            uuid (str): The UUID of the table to get.
+            user_id (int): Specific user. privileges required.
+
+        Returns:
+            Table: The Table object.
+
+        Raises:
+            NotFoundError: If the table with the specified UUID is not found.
+
+        Example:
+            >>> from geobox import GeoboxClient
+            >>> client = GeoboxClient()
+            >>> table = client.get_table(uuid="12345678-1234-5678-1234-567812345678")
+        """
+        return Table.get_table(self, uuid, user_id)
+
+
+    def get_table_by_name(self, 
+        name: str, 
+        user_id: int = None,
+    ) -> Union['Table', None]:
+        """
+        Get a table by name
+
+        Args:
+            name (str): the name of the table to get
+            user_id (int, optional): specific user. privileges required.
+
+        Returns:
+            Table | None: returns the table if a table matches the given name, else None
+
+        Example:
+            >>> from geobox import GeoboxClient
+            >>> client = GeoboxClient()
+            >>> table = client.get_table_by_name(name='test')
+
+        """
+        return Table.get_table_by_name(self, name, user_id)

geobox/enums.py

@@ -429,4 +429,8 @@ class SpatialPredicate(Enum):
     EQUAL = 'Equal'
     OVERLAP = 'Overlap'
     TOUCH = 'Touch'
-    WITHIN = 'Within'
+    WITHIN = 'Within'
+
+
+class TableExportFormat(Enum):
+    CSV = 'CSV'

geobox/field.py

@@ -15,10 +15,11 @@ if TYPE_CHECKING:
 class Field(Base):
 
     def __init__(self, 
-                 layer: 'VectorLayer',
-                 data_type: 'FieldType',
-                 field_id: int = None,
-                 data: Optional[Dict] = {}):
+        layer: 'VectorLayer',
+        data_type: 'FieldType',
+        field_id: int = None,
+        data: Optional[Dict] = {},
+    ):
         """
         Constructs all the necessary attributes for the Field object.
 
@@ -82,7 +83,13 @@ class Field(Base):
         
 
     @classmethod
-    def create_field(cls, api: 'GeoboxClient', layer: 'VectorLayer', name: str, data_type: 'FieldType', data: Dict = {}) -> 'Field':
+    def create_field(cls, 
+        api: 'GeoboxClient', 
+        layer: 'VectorLayer', 
+        name: str, 
+        data_type: 'FieldType', 
+        data: Dict = {},
+    ) -> 'Field':
         """
         Create a new field
 
@@ -261,7 +268,10 @@ class Field(Base):
         return self.layer.api.get(endpoint)
 
 
-    def update_domain(self, range_domain: Dict = None, list_domain: Dict = None) -> Dict:
+    def update_domain(self, 
+        range_domain: Dict = None, 
+        list_domain: Dict = None,
+    ) -> Dict:
         """
         Update field domian values
 
@@ -277,9 +287,10 @@ class Field(Base):
             >>> client = GeoboxClient()
             >>> field = client.get_vector(uuid="12345678-1234-5678-1234-567812345678").get_fields()[0]
             >>> range_d = {'min': 1, 'max': 10}
+            >>> field.update_domain(range_domain = range_d)
+            or
             >>> list_d = {'1': 'value1', '2': 'value2'}
-            >>> field.update_domain(range_domain = range_d, list_domain=list_d)
-            {'min': 1, 'max': 10, 'items: {'1': 'value1', '2': 'value2'}}
+            >>> field.update_domain(list_domain=list_d)
         """
         if not self.domain:
             self.domain = {'min': None, 'max': None, 'items': {}}
@@ -291,7 +302,7 @@ class Field(Base):
         if list_domain:
             self.domain['items'] = {**self.domain['items'], **list_domain}
 
-        self.save()
+        self.update(domain=self.domain)
         return self.domain
 
 
@@ -318,4 +329,4 @@ class Field(Base):
         from .aio.field import AsyncField
 
         async_layer = self.layer.to_async(async_client=async_client)
-        return AsyncField(layer=async_layer, data_type=self.data_type, field_id=self.field_id, data=self.data)
+        return AsyncField(layer=async_layer, data_type=self.data_type, field_id=self.field_id, data=self.data)