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

geobox/task.py

@@ -1,4 +1,4 @@
-from urllib.parse import urljoin, urlencode
+from urllib.parse import urljoin
 from typing import Optional, Dict, List, Optional, Union, TYPE_CHECKING
 import time
 import logging
@@ -13,8 +13,7 @@ if TYPE_CHECKING:
     from .model3d import Model
     from .file import File
     from .tile3d import Tile3d
-    from .aio import AsyncGeoboxClient
-    from .aio.task import AsyncTask
+
 
 logger = logging.getLogger(__name__)
 
@@ -375,29 +374,3 @@ class Task(Base):
             >>> task = client.get_task(uuid="12345678-1234-5678-1234-567812345678")
         """
         return super()._get_detail(api, cls.BASE_ENDPOINT, uuid, factory_func=lambda api, item: Task(api, item['uuid'], item))
-
-
-    def to_async(self, async_client: 'AsyncGeoboxClient') -> 'AsyncTask':
-        """
-        Switch to async version of the task instance to have access to the async methods
-
-        Args:
-            async_client (AsyncGeoboxClient): The async version of the GeoboxClient instance for making requests.
-
-        Returns:
-            AsyncTask: the async instance of the task.
-
-        Example:
-            >>> from geobox import Geoboxclient
-            >>> from geobox.aio import AsyncGeoboxClient
-            >>> from geobox.task import Task
-            >>> client = GeoboxClient()
-            >>> task = Task.get_task(client, uuid="12345678-1234-5678-1234-567812345678")
-            or
-            >>> task = client.get_task(uuid="12345678-1234-5678-1234-567812345678")
-            >>> async with AsyncGeoboxClient() as async_client:
-            >>>     async_task = task.to_async(async_client)
-        """
-        from .aio.task import AsyncTask
-
-        return AsyncTask(api=async_client, uuid=self.uuid, data=self.data)

geobox/tile3d.py

@@ -6,8 +6,6 @@ from .base import Base
 if TYPE_CHECKING:
     from . import GeoboxClient
     from .user import User
-    from .aio import AsyncGeoboxClient
-    from .aio.tile3d import AsyncTile3d
 
 
 class Tile3d(Base):
@@ -312,27 +310,3 @@ class Tile3d(Base):
         """
         endpoint = urljoin(self.endpoint, 'tileset.json') 
         return self.api.get(endpoint)
-    
-
-    def to_async(self, async_client: 'AsyncGeoboxClient') -> 'AsyncTile3d':
-        """
-        Switch to async version of the 3d tile instance to have access to the async methods
-
-        Args:
-            async_client (AsyncGeoboxClient): The async version of the GeoboxClient instance for making requests.
-
-        Returns:
-            AsyncTile3d: the async instance of the 3d tile.
-
-        Example:
-            >>> from geobox import Geoboxclient
-            >>> from geobox.aio import AsyncGeoboxClient
-            >>> from geobox.tile3d import Tile3d
-            >>> client = GeoboxClient()
-            >>> tile = Tile3d.get_3dtile(api=client, uuid="12345678-1234-5678-1234-567812345678")
-            >>> async with AsyncGeoboxClient() as async_client:
-            >>>     async_tile = tile.to_async(async_client)
-        """
-        from .aio.tile3d import AsyncTile3d
-
-        return AsyncTile3d(api=async_client, uuid=self.uuid, data=self.data)

geobox/tileset.py

@@ -9,8 +9,7 @@ from .task import Task
 if TYPE_CHECKING:
     from . import GeoboxClient 
     from .user import User 
-    from .aio import AsyncGeoboxClient
-    from .aio.tileset import AsyncTileset
+
 
 class Tileset(Base):
 
@@ -632,27 +631,3 @@ class Tileset(Base):
             >>> tileset.clear_cache()
         """
         super()._clear_cache(endpoint=self.endpoint)
-
-
-    def to_async(self, async_client: 'AsyncGeoboxClient') -> 'AsyncTileset':
-        """
-        Switch to async version of the tileset instance to have access to the async methods
-
-        Args:
-            async_client (AsyncGeoboxClient): The async version of the GeoboxClient instance for making requests.
-
-        Returns:
-            AsyncTileset: the async instance of the tileset.
-
-        Example:
-            >>> from geobox import Geoboxclient
-            >>> from geobox.aio import AsyncGeoboxClient
-            >>> from geobox.tileset import Tileset
-            >>> client = GeoboxClient()
-            >>> tileset = Tileset.get_tileset(client, uuid="12345678-1234-5678-1234-567812345678")
-            >>> async with AsyncGeoboxClient() as async_client:
-            >>>     async_tileset = tileset.to_async(async_client)
-        """
-        from .aio.tileset import AsyncTileset
-
-        return AsyncTileset(api=async_client, uuid=self.uuid, data=self.data)

geobox/usage.py

@@ -1,5 +1,5 @@
-from urllib.parse import urlencode, urljoin
-from typing import Optional, Dict, List, Union, TYPE_CHECKING
+from urllib.parse import urlencode
+from typing import Dict, List, Union, TYPE_CHECKING
 from datetime import datetime
 
 from .base import Base
@@ -10,8 +10,6 @@ from .enums import UsageScale, UsageParam
 
 if TYPE_CHECKING:
     from . import GeoboxClient
-    from .aio import AsyncGeoboxClient
-    from .aio.usage import AsyncUsage
 
 
 class Usage(Base):
@@ -211,32 +209,3 @@ class Usage(Base):
         })
         endpoint = f"{cls.BASE_ENDPOINT}update"
         return api.post(endpoint, payload=data)
-    
-
-    def to_async(self, async_client: 'AsyncGeoboxClient') -> 'AsyncUsage':
-        """
-        Switch to async version of the usage instance to have access to the async methods
-
-        Args:
-            async_client (AsyncGeoboxClient): The async version of the GeoboxClient instance for making requests.
-
-        Returns:
-            AsyncUsage: the async instance of the usage.
-
-        Example:
-            >>> from geobox import Geoboxclient
-            >>> from geobox.aio import AsyncGeoboxClient
-            >>> from geobox.usage import Usage
-            >>> client = GeoboxClient()
-            >>> user = client.get_user()
-            >>> usage = Usage.get_api_usage(client, 
-            ...                               resource=user, 
-            ...                               scale=UsageScale.Day, 
-            ...                               param=UsageParam.Calls, 
-            ...                               days_before_now=5)
-            >>> async with AsyncGeoboxClient() as async_client:
-            >>>     async_usage = usage.to_async(async_client)
-        """
-        from .aio.usage import AsyncUsage
-
-        return AsyncUsage(api=async_client, user=self.user)

geobox/user.py

@@ -1,4 +1,4 @@
-from typing import List, Any, TYPE_CHECKING, Union, Dict
+from typing import List, TYPE_CHECKING, Union, Dict
 from urllib.parse import urlencode, urljoin
 
 from .base import Base
@@ -8,9 +8,6 @@ from .plan import Plan
 
 if TYPE_CHECKING:
     from . import GeoboxClient
-    from .aio import AsyncGeoboxClient
-    from .aio.user import AsyncUser
-    from .aio.user import AsyncSession
 
 
 class User(Base):
@@ -399,33 +396,6 @@ class User(Base):
         self.api.post(endpoint)
 
 
-    def to_async(self, async_client: 'AsyncGeoboxClient') -> 'AsyncUser':
-        """
-        Switch to async version of the user instance to have access to the async methods
-
-        Args:
-            async_client (AsyncGeoboxClient): The async version of the GeoboxClient instance for making requests.
-
-        Returns:
-            AsyncUser: the async instance of the user.
-
-        Example:
-            >>> from geobox import Geoboxclient
-            >>> from geobox.aio import AsyncGeoboxClient
-            >>> from geobox.user import User
-            >>> client = GeoboxClient()
-            >>> user = User.get_user(client) # without user_id parameter, it gets the current user
-            or
-            >>> user = client.get_user() # without user_id parameter, it gets the current user
-            >>> async with AsyncGeoboxClient() as async_client:
-            >>>     async_user = user.to_async(async_client)
-        """
-        from .aio.user import AsyncUser
-
-        return AsyncUser(api=async_client, user_id=self.user_id, data=self.data)
-
-
-
 class Session(Base):
     def __init__(self, uuid: str, data: Dict, user: 'User'):
         """
@@ -474,31 +444,3 @@ class Session(Base):
             'session_uuid': self.uuid
         })
         self.user.api.post(self.endpoint, data)
-
-
-    def to_async(self, async_client: 'AsyncGeoboxClient') -> 'AsyncSession':
-        """
-        Switch to async version of the session instance to have access to the async methods
-
-        Args:
-            async_client (AsyncGeoboxClient): The async version of the GeoboxClient instance for making requests.
-
-        Returns:
-            AsyncSession: the async instance of the session.
-
-        Example:
-            >>> from geobox import Geoboxclient
-            >>> from geobox.aio import AsyncGeoboxClient
-            >>> from geobox.user import User
-            >>> client = GeoboxClient()
-            >>> user = User.get_user(client) # without user_id parameter, it gets the current user
-            or
-            >>> user = client.get_user() # without user_id parameter, it gets the current user
-            >>> session = user.get_sessions()[0]
-            >>> async with AsyncGeoboxClient() as async_client:
-            >>>     async_session = session.to_async(async_client)
-        """
-        from .aio.user import AsyncSession
-        
-        async_user = self.user.to_async(async_client=async_client)
-        return AsyncSession(uuid=self.uuid, data=self.data, user=async_user)

geobox/vector_tool.py

@@ -1965,4 +1965,53 @@ class VectorTool(Base):
             'srid': srid
         }
         query = self._add_params_to_query(query_name='$xy_coordinate', inputs=inputs)
+        return self._run_query(query=query, output_layer_name=output_layer_name)
+
+
+    def table_to_vectorlayer(self,
+        table_uuid: str,
+        lon_field: str,
+        lat_field: str,
+        output_layer_name: Optional[str] = None,
+    ) -> Union['Task', Dict]:
+        """
+        Converts a table to a vector layer by converting the lon and lat columns to a point geometry.
+
+        Args:
+            table_uuid (str): UUID of the vector layer
+            lon_field (str): field name containing lon value
+            lat_field (str): field name containing lat value
+            output_layer_name (str, optional): Name for the output layer. name must be a valid identifier and without spacing.
+        
+        Returns:
+            Union['Task', Dict]: If output_layer_name is specified, the function returns a task object; if not, it returns the vector tool execution result.
+
+        Example:
+            >>> from geobox import GeoboxClient
+            >>> client = GeoboxClient()
+            >>> table = client.get_table(uuid="12345678-1234-5678-1234-567812345678")
+            
+            >>> # execution
+            >>> result = client.vector_tool.table_to_vectorlayer(
+            ...     table_uuid=table.uuid, 
+            ...     lon_field="lon_field_name",
+            ...     lat_field="lat_field_name",
+            ... )
+            
+            >>> # save as layer
+            >>> task = client.vector_tool.table_to_vectorlayer(
+            ...     table_uuid=table.uuid, 
+            ...     lon_field="lon_field_name",
+            ...     lat_field="lat_field_name",
+            ...     output_layer_name="output_layer",
+            ... )
+            >>> task.wait()
+            >>> output_layer = task.output_asset
+        """
+        inputs = {
+            'table': table_uuid,
+            'lon': lon_field,
+            'lat': lat_field,
+        }
+        query = self._add_params_to_query(query_name='$tabel_to_vector_layer', inputs=inputs)
         return self._run_query(query=query, output_layer_name=output_layer_name)

geobox/vectorlayer.py

@@ -8,7 +8,7 @@ from .field import Field, FieldType
 from .feature import Feature
 from .enums import LayerType
 from .task import Task
-from .enums import InputGeomType, FileOutputFormat, AnalysisDataType
+from .enums import InputGeomType, FileOutputFormat
 from .version import VectorLayerVersion
 
 if TYPE_CHECKING:
@@ -17,8 +17,6 @@ if TYPE_CHECKING:
     from .user import User
     from .file import File
     from .attachment import Attachment
-    from .aio import AsyncGeoboxClient
-    from .aio.vectorlayer import AsyncVectorLayer
 
 
 class VectorLayer(Base):
@@ -669,6 +667,8 @@ class VectorLayer(Base):
                             If False, returns a list of Feature objects. default: False.
 
         Keyword Args:
+            relationship_uuid (str): The uuid of relationship
+            related_record_id (int): This is the id of the feature or row that these features are related to. This id blongs to the related layer or table not this layer
             quant_factor (int): Quantization factor. This parameter is only used by topojson encoder and is ignored for other formats. Higher quantizaion value means higher geometry precision. default is 1000000.
             skip (int): Number of features to skip. default is 0.
             limit (int): Maximum number of features to return. default is 100.
@@ -705,6 +705,8 @@ class VectorLayer(Base):
         """
         params = {
             'f': 'json',
+            'relationship_uuid': kwargs.get('relationship_uuid'),
+            'related_record_id': kwargs.get('related_record_id'),
             'quant_factor': kwargs.get('quant_factor', 1000000),
             'skip': kwargs.get('skip', 0),
             'limit': kwargs.get('limit', 100),
@@ -1022,15 +1024,10 @@ class VectorLayer(Base):
                             data=data,
                             factory_func=lambda api, item: VectorLayerView(api, item['uuid'], self.layer_type, item))
 
-
-    def get_tile_pbf_url(self, x: int = '{x}', y: int = '{y}', z: int = '{z}') -> str:
+    @property
+    def tile_pbf_url(self) -> str:
         """
         Get a vector tile pbf url for the layer.
-        
-        Args:
-            x (int, optional): X coordinate of the tile.
-            y (int, optional): Y coordinate of the tile.
-            z (int, optioanl): Zoom level of the tile.
 
         Returns:
             str: The vector tile url.
@@ -1040,9 +1037,9 @@ class VectorLayer(Base):
             >>> from geobox.vectorlayer import VectorLayer
             >>> client = GeoboxClient()
             >>> layer = VectorLayer.get_vector(api=client, uuid="12345678-1234-5678-1234-567812345678")
-            >>> tile = layer.get_tile(x=10, y=20, z=1)
+            >>> url = layer.tile_pbf_url
         """
-        endpoint = f'{self.api.base_url}{self.endpoint}tiles/{z}/{x}/{y}.pbf'
+        endpoint = f'{self.api.base_url}{self.endpoint}' + 'tiles/{z}/{x}/{y}.pbf'
 
         if not self.api.access_token and self.api.apikey:
             endpoint = f'{endpoint}?apikey={self.api.apikey}'
@@ -1347,27 +1344,3 @@ class VectorLayer(Base):
                                             feature=feature,
                                             display_name=display_name,
                                             description=description)
-    
-
-    def to_async(self, async_client: 'AsyncGeoboxClient') -> 'AsyncVectorLayer':
-        """
-        Switch to async version of the vector layer instance to have access to the async methods
-
-        Args:
-            async_client (AsyncGeoboxClient): The async version of the GeoboxClient instance for making requests.
-
-        Returns:
-            AsyncVectorLayer: the async instance of the vector layer.
-
-        Example:
-            >>> from geobox import Geoboxclient
-            >>> from geobox.aio import AsyncGeoboxClient
-            >>> from geobox.vectorlayer import VectorLayer
-            >>> client = GeoboxClient()
-            >>> layer = VectorLayer.get_vector(client, uuid="12345678-1234-5678-1234-567812345678")
-            >>> async with AsyncGeoboxClient() as async_client:
-            >>>     async_layer = layer.to_async(async_client)
-        """
-        from .aio.vectorlayer import AsyncVectorLayer
-
-        return AsyncVectorLayer(api=async_client, uuid=self.uuid, layer_type=self.layer_type, data=self.data)

geobox/version.py

@@ -5,8 +5,7 @@ from .base import Base
 if TYPE_CHECKING:
     from .api import GeoboxClient
     from .user import User
-    from .aio import AsyncGeoboxClient
-    from .aio.version import VectorLayerVersion as AsyncVectorLayerVersion
+
 
 class VectorLayerVersion(Base):
 
@@ -247,27 +246,3 @@ class VectorLayerVersion(Base):
             'limit': limit
         }
         return super()._get_shared_users(self.endpoint, params)
-
-    
-    def to_async(self, async_client: 'AsyncGeoboxClient') -> 'AsyncVectorLayerVersion':
-        """
-        Switch to async version of the version instance to have access to the async methods
-
-        Args:
-            async_client (AsyncGeoboxClient): The async version of the GeoboxClient instance for making requests.
-
-        Returns:
-            AsyncVectorLayerVersion: the async instance of the version.
-
-        Example:
-            >>> from geobox import Geoboxclient
-            >>> from geobox.aio import AsyncGeoboxClient
-            >>> from geobox.version import VectorLayerversion
-            >>> client = GeoboxClient()
-            >>> version = VectorLayerversion.get_version(client, uuid="12345678-1234-5678-1234-567812345678")
-            >>> async with AsyncGeoboxClient() as async_client:
-            >>>     async_version = version.to_async(async_client)
-        """
-        from .aio.version import AsyncVectorLayerVersion
-
-        return AsyncVectorLayerVersion(api=async_client, uuid=self.uuid, data=self.data)

geobox/view.py

@@ -11,8 +11,6 @@ if TYPE_CHECKING:
     from .task import Task
     from .file import File
     from .attachment import Attachment
-    from .aio import AsyncGeoboxClient
-    from .aio.view import AsyncVectorLayerView
 
 
 class VectorLayerView(VectorLayer):
@@ -665,14 +663,10 @@ class VectorLayerView(VectorLayer):
                                        bbox, out_srid, zipped, feature_ids, bbox_srid, q, fields)
 
     
-    def get_tile_pbf_url(self, x: int = '{x}', y: int = '{y}', z: int = '{z}') -> str:
+    @property
+    def tile_pbf_url(self) -> str:
         """
         Get a vector tile pbf url for the view.
-        
-        Args:
-            x (int): X coordinate of the tile.
-            y (int): Y coordinate of the tile.
-            z (int): Zoom level of the tile.
 
         Returns:
             str: the vector tile url.
@@ -682,9 +676,9 @@ class VectorLayerView(VectorLayer):
             >>> from geobox.view import VectorLayerView
             >>> client = GeoboxClient()
             >>> view = VectorLayerView.get_view(client, uuid="12345678-1234-5678-1234-567812345678")
-            >>> tile = view.get_tile(x=10, y=20, z=1)
+            >>> url = view.tile_pbf_url
         """
-        return super().get_tile_pbf_url(x, y, z)
+        return super().tile_pbf_url
     
 
     def get_tile_json(self) -> Dict:
@@ -960,27 +954,3 @@ class VectorLayerView(VectorLayer):
                                             feature=feature,
                                             display_name=display_name,
                                             description=description)
-    
-
-    def to_async(self, async_client: 'AsyncGeoboxClient') -> 'AsyncVectorLayerView':
-        """
-        Switch to async version of the view instance to have access to the async methods
-
-        Args:
-            async_client (AsyncGeoboxClient): The async version of the GeoboxClient instance for making requests.
-
-        Returns:
-            AsyncVectorLayerView: the async instance of the view.
-
-        Example:
-            >>> from geobox import Geoboxclient
-            >>> from geobox.aio import AsyncGeoboxClient
-            >>> from geobox.view import VectorLayerView
-            >>> client = GeoboxClient()
-            >>> view = VectorLayerView.get_view(client, uuid="12345678-1234-5678-1234-567812345678")
-            >>> async with AsyncGeoboxClient() as async_client:
-            >>>     async_view = view.to_async(async_client)
-        """
-        from .aio.view import AsyncVectorLayerView
-
-        return AsyncVectorLayerView(api=async_client, uuid=self.uuid, layer_type=self.layer_type, data=self.data)

geobox/workflow.py

@@ -5,8 +5,7 @@ from .base import Base
 if TYPE_CHECKING:
     from . import GeoboxClient
     from .user import User
-    from .aio import AsyncGeoboxClient
-    from .aio.workflow import Workflow as AsyncWorkflow 
+
 
 class Workflow(Base):
 
@@ -313,27 +312,3 @@ class Workflow(Base):
             'limit': limit
         }
         return super()._get_shared_users(self.endpoint, params)
-
-
-    def to_async(self, async_client: 'AsyncGeoboxClient') -> 'AsyncWorkflow':
-        """
-        Switch to async version of the workflow instance to have access to the async methods
-
-        Args:
-            async_client (AsyncGeoboxClient): The async version of the GeoboxClient instance for making requests.
-
-        Returns:
-            AsyncWorkflow: the async instance of the workflow.
-
-        Example:
-            >>> from geobox import Geoboxclient
-            >>> from geobox.aio import AsyncGeoboxClient
-            >>> from geobox.workflow import Workflow
-            >>> client = GeoboxClient()
-            >>> workflow = Workflow.get_workflow(client, uuid="12345678-1234-5678-1234-567812345678")
-            >>> async with AsyncGeoboxClient() as async_client:
-            >>>     async_workflow = workflow.to_async(async_client)
-        """
-        from .aio.workflow import AsyncWorkflow
-
-        return AsyncWorkflow(api=async_client, uuid=self.uuid, data=self.data)

{geobox-2.3.0.dist-info → geobox-2.4.0.dist-info}/METADATA

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

geobox-2.4.0.dist-info/RECORD

@@ -0,0 +1,74 @@
+geobox/__init__.py,sha256=zGYCpxmYA06-PNNSRqRUNhiuoaM5a8x68qqQbJ-z9hs,1922
+geobox/api.py,sha256=KPncJY6oVPLP_Mt3ewtrLQyAHoUY0O3REG_uxS4fuyc,116350
+geobox/apikey.py,sha256=chtq19VqssH382bEsOS4ohZYmuhs3bDD1WUIZo5YwE8,7762
+geobox/attachment.py,sha256=jYZa8s_odNYT1EcS0VQo9chs9UhYjIrzXNVj_5r8ZJA,12127
+geobox/base.py,sha256=paE3-Wshzp4ykpkbXdIZ6MVPDwyTRgrr-OTYd9BK2o8,13353
+geobox/basemap.py,sha256=8FS4v_7bmmPzc3eJVo8SXn_wTx47l-cGx52RiSHRWPU,4642
+geobox/dashboard.py,sha256=ej6gytUega6YWuUb4FmW6nBtaPaXaKJVJCI9_QPPIEM,11930
+geobox/enums.py,sha256=IRJixg7X4LBvnkwJZjV3hskja924kHjvI4fHsK7gsjE,8319
+geobox/exception.py,sha256=jvpnv0M2Ck1FpxHTL_aKYWxGvLnCQ3d9vOrMIktjw1U,1507
+geobox/feature.py,sha256=PD-OPM8GtkWzHa_DOB5NlMgqSEvZ3aBn7hkt1djnc1c,25886
+geobox/field.py,sha256=tCuGOauZR4EhvoFw9GtfKnxX-qeGjenGt4btQDOo6fM,10043
+geobox/file.py,sha256=V_J7_9n83lkXETlpIzcW6Do0OTboWZiJjZbfVipOkAo,19187
+geobox/layout.py,sha256=YgFYgzLxRstDDSqt34JZ1eVnInxTQTmUjnR2M50ItbM,11547
+geobox/log.py,sha256=oDukjftcQViuVxS5nHQFW7t0usUI8RLa9IImRWB76UI,4029
+geobox/map.py,sha256=LXnpGrdyQoAZvX-h91QbFXQvVTq54qhUFXYkCEK9Smo,38018
+geobox/model3d.py,sha256=JSKprwM5tP1xvXEYlHgNNmLLKZZAQLRT-xH54OxoU4I,14261
+geobox/mosaic.py,sha256=oCd8WRSx8BfOizHnNycuRzxpmxM2IaLUc4BLpEu5ICg,24750
+geobox/plan.py,sha256=zq6YY3TTPI7hQqW07Mk9QVG1gE9kNEdInqLeZv62wT8,12349
+geobox/query.py,sha256=UERu8Iav7smQTuDKpqJpgVKL8vFc3fBVL9mYXH_xpXI,24961
+geobox/raster.py,sha256=BCrx7GyvKGb9B_CsnD1Dg4zRTl_PqQH3MnD520X3e1w,32496
+geobox/raster_analysis.py,sha256=yoWA5_-GixyAJMpo8cHmZcYrEYUvwo2395BwrGlUBaA,34920
+geobox/route.py,sha256=cKZTTHBHM8woWbhHIpCvrRX_doJcTkGktouee0z7oG0,2723
+geobox/scene.py,sha256=wjS5K5d2aIEcB9shAU6RaINQoLIpqRH6UEMo_kKfQBg,11538
+geobox/settings.py,sha256=NqWjIaYhwBsnHeTBgxeftyGUtFoKiMeggxDWw7w_Qro,5823
+geobox/table.py,sha256=tuFljp4QnOGXMjTo6E6vLh4z4pyeSRoVpp3eGyMS1_8,64381
+geobox/task.py,sha256=ZWY6VYcyMlRlxjMa0JoZgqjC2kDX_iN-MfyxfhRGOxw,13796
+geobox/tile3d.py,sha256=_27j9b7SfCUGaP61xnpZV2tJ4PWYUcLAMj53efBosK8,11286
+geobox/tileset.py,sha256=YlY8LMJiAOcEoMUDonrQnTk8rvjaN7S8OcPgpyyxn_s,23955
+geobox/usage.py,sha256=z75Psp752vGmCoGeYBG4Kala-c9OY8zYZvvNVM5FFtU,7890
+geobox/user.py,sha256=PAVpFiYAcvqT7UO-Y9y5CKNJ48GSl-XtxwNgen0uqyU,15526
+geobox/utils.py,sha256=JmlRqDVIo0vBikzH1XakRrCrEIfLA7_eTJnBWBvGhJI,2243
+geobox/vector_tool.py,sha256=VwxZRaI_GXZHkrjSfJkY8Bv0xE3QcCpDUI9PP68hMgQ,88291
+geobox/vectorlayer.py,sha256=DNBObV-0FHRMFARx0jnAeB94zS_wguCc8CvdRTGIJNg,57782
+geobox/version.py,sha256=XwScsj3A2-b3jFtPZ08LiAd7uPuUDOFTU5UyKlf317Y,9619
+geobox/view.py,sha256=7Ew3jZlQjb0Yu-ZSs6MvB2hJkga2OsHqGfIfC3IzKiA,41992
+geobox/workflow.py,sha256=RP5yjE8aaUd31Sw-bpIbKu2TUP_6mhyvepBj5zI_Q6c,11827
+geobox/aio/__init__.py,sha256=4Ufsv-VOW7FQGD1OmSRKH7E3sLCaKC0MpEMsSMBC3ro,1933
+geobox/aio/api.py,sha256=y4Uf7OUdAob8JGJvIven8ufxkUDLKIyGrVGtYxxCuc0,120858
+geobox/aio/apikey.py,sha256=xcB32URNYbHTvnzOyTCnEfejN7kIRGLCrUUp8NDQc0M,8434
+geobox/aio/attachment.py,sha256=-RP49z_-oW7mjjwQ4WuWbZKt0_8OXUOReBCeRfJkdEs,12273
+geobox/aio/base.py,sha256=H9CB-5Gas3c1Xp14nW-PS-syoGNBpyRLN2iujlSxWLU,9455
+geobox/aio/basemap.py,sha256=coAPc6-jf2n27pTh9vrRSUPCw7_kmefDH8OU8w6WjNI,5015
+geobox/aio/dashboard.py,sha256=XtB1VX9GKERFPrgqj9Git05W74aXq49pC0uhVvUFi4M,12765
+geobox/aio/feature.py,sha256=k6_Y4d33kuKpWk1nDP4MryilZ8Eokx_CN1e0jQpQnQw,26459
+geobox/aio/field.py,sha256=af5QGojQ7PisnlQdDumyXZUI1vNMnvt85vpn1AhKUT0,10401
+geobox/aio/file.py,sha256=c7zAN-EdDcsycX59whMKy0KWhbWNsjz0ozzm0RZ3DB4,20243
+geobox/aio/layout.py,sha256=jLMgWEG0O-4AJUtk8z6-QZQoUt197A_W9qolxgX7OGM,12441
+geobox/aio/log.py,sha256=GQzq1Sv5PQve6IYfJ_tGqtx26qCNuMf0OmA1QTdoDCc,4354
+geobox/aio/map.py,sha256=RhKtf0lyy2klB6Ql-2Q1MYur_azpY7q6lPZj52GC3MA,40246
+geobox/aio/model3d.py,sha256=jJgivii3goxjNQBN5NdqTest1hBXwhaIttdamqRdGDg,15414
+geobox/aio/mosaic.py,sha256=19rtSBu2sYRDLbz0UNrqOHLZvfYRrFGRoKYruAd2IRQ,26930
+geobox/aio/plan.py,sha256=_JLml0WqaS1F-jmABAQ609SfJpoMxHFK_mgW_lllCfc,12893
+geobox/aio/query.py,sha256=A5JpnWfDsL6LLCJxKtpwm-LdTvvZ68NMZKnFLsYLvGI,26763
+geobox/aio/raster.py,sha256=6fd7OBBllnZT8n3y5N0qCiG9dDh1zPsnXq1FXImzZkM,34880
+geobox/aio/raster_analysis.py,sha256=aSU_E8TXrex2x9w3S4WCWGTu0q81qOBN0rXo5uG5IgM,36672
+geobox/aio/route.py,sha256=dkKsK4ZjL7XikgoZ3lJfkr2UXwrmxct4Qt2DzZg0upE,2860
+geobox/aio/scene.py,sha256=sLvYAv9Im6QBfopK2TxTt0DeUl5lZ_GI8W6_vmAr-fg,12390
+geobox/aio/settings.py,sha256=dOt1EWHW283lovQM8ZnZTES0QMOPhcHYhtwLF7WV8ts,5875
+geobox/aio/table.py,sha256=t9AzHCWVdLsuNpLNQgrajMLj8jgRYuEwPTbgtw1XG_Q,69549
+geobox/aio/task.py,sha256=j_p09FcEZDhtKjCi7VzxTVSSvtcpxRBbvXRBkdiyxy4,14841
+geobox/aio/tile3d.py,sha256=VMc6fIoPuxKgAjfTHB-2rnXiMhGhb6eAWgnFqditVBA,12236
+geobox/aio/tileset.py,sha256=AaPt6Q2zh2YZNPE0QHjkbwH-TR-fcHmMMJkZrQeeANs,26619
+geobox/aio/usage.py,sha256=QUV71c8ZCjfaOlpba5yF78N6P7sSWENpRiEJ12NYvTc,8162
+geobox/aio/user.py,sha256=ZCT1uSsxOTuAnWaH9uiE-fN0cf1onARF9xxgPa2b-h8,16630
+geobox/aio/vector_tool.py,sha256=MTBQm5UmzP-wE2acP_TnTTkc8HEbWoWvt6hyNAOZvGg,95025
+geobox/aio/vectorlayer.py,sha256=AHjbxxv6pI7bc4OAozemAm1-4vidAUcbwyCO4vqSzQs,58829
+geobox/aio/version.py,sha256=EFb14Xd4AYzwtcv9Y2lj9hmokd34Q3RBdKLu9bgRUOw,10380
+geobox/aio/view.py,sha256=uVhSGc6vQGzKjt_06hhdClbEuzIG3HGrrn8f2MkS2C8,44106
+geobox/aio/workflow.py,sha256=Q0IRb_4avRWz3Y8IZW41F6SBPjaCtzlD5hheg6ggXVM,12645
+geobox-2.4.0.dist-info/licenses/LICENSE,sha256=AvFB7W94sJYKLDhBxLRshL3upexCOG8HQY_1JibB96w,1063
+geobox-2.4.0.dist-info/METADATA,sha256=mfGrIR3m28VjGj9M2qhAiCezGQltZ5x32ecm2fI4zSw,3089
+geobox-2.4.0.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+geobox-2.4.0.dist-info/top_level.txt,sha256=ppXH8Bu2mlB-pLQ6lsoWEm2Gr6wZx1uzkhetsYA5ins,7
+geobox-2.4.0.dist-info/RECORD,,

{geobox-2.3.0.dist-info → geobox-2.4.0.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (80.9.0)
+Generator: setuptools (80.10.2)
 Root-Is-Purelib: true
 Tag: py3-none-any