geobox 1.4.1__py3-none-any.whl → 2.0.0__py3-none-any.whl

geobox/tileset.py

@@ -9,14 +9,11 @@ from .task import Task
 if TYPE_CHECKING:
     from . import GeoboxClient 
     from .user import User 
+    from .aio import AsyncGeoboxClient
+    from .aio.tileset import Tileset as AsyncTileset
 
 class Tileset(Base):
-    """
-    A class to interact with tilesets in Geobox.
 
-    This class provides functionality to interact with tilesets in Geobox.
-    It supports various operations including CRUD operations on tilesets, as well as advanced operations like getting layers, and sharing tilesets.
-    """
     BASE_ENDPOINT: str = 'tilesets/'
 
     def __init__(self, 
@@ -635,3 +632,27 @@ 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:
+            geobox.aio.tileset.Tileset: 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 Tileset as AsyncTileset
+
+        return AsyncTileset(api=async_client, uuid=self.uuid, data=self.data)

geobox/usage.py

@@ -10,6 +10,8 @@ from .enums import UsageScale, UsageParam
 
 if TYPE_CHECKING:
     from . import GeoboxClient
+    from .aio import AsyncGeoboxClient
+    from .aio.usage import Usage as AsyncUsage
 
 
 class Usage(Base):
@@ -208,4 +210,33 @@ class Usage(Base):
             'user_id': user_id if user_id else None
         })
         endpoint = f"{cls.BASE_ENDPOINT}update"
-        return api.post(endpoint, payload=data)
+        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:
+            geobox.aio.usage.Usage: 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 Usage as AsyncUsage
+
+        return AsyncUsage(api=async_client, user=self.user)

geobox/user.py

@@ -8,6 +8,9 @@ from .plan import Plan
 
 if TYPE_CHECKING:
     from . import GeoboxClient
+    from .aio import AsyncGeoboxClient
+    from .aio.user import Session as AsyncSession
+    from .aio.user import User as AsyncUser
 
 
 class User(Base):
@@ -270,7 +273,7 @@ class User(Base):
             >>> from geobox.user import User
             >>> client = GeoboxClient()
             >>> user = User.get_user(client, user_id=1)
-            >>> user.update_user(status=UserStatus.PENDING)
+            >>> user.update(status=UserStatus.PENDING)
         """
         data = {
             "username": kwargs.get('username'),
@@ -337,9 +340,9 @@ class User(Base):
             or
             >>> user = client.get_user(user_id=1)
 
-            >>> user.get_user_sessions()       
+            >>> user.get_sessions()       
             or
-            >>> client.get_user_sessions()
+            >>> client.get_sessions()
         """
         params = clean_data({
             'f': 'json'
@@ -370,7 +373,7 @@ class User(Base):
             >>> from geobox import GeoboxClient
             >>> from geobox.user import User
             >>> client = GeoboxClient()
-            >>> user = client.get_user()
+            >>> user = client.get_user(user_id=1)
             >>> user.change_password(new_password='user_new_password')
         """
         data = clean_data({
@@ -382,7 +385,7 @@ class User(Base):
 
     def renew_plan(self) -> None:
         """
-        Renew the user plan
+        Renew the user plan (privileges required)
 
         Returns:
             None
@@ -396,6 +399,31 @@ 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:
+            geobox.aio.user.User: 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 User as AsyncUser
+
+        return AsyncUser(api=async_client, user_id=self.user_id, data=self.data)
+
 
 
 class Session(Base):
@@ -445,4 +473,32 @@ class Session(Base):
             'user_id': self.user.user_id,
             'session_uuid': self.uuid
         })
-        self.user.api.post(self.endpoint, data)
+        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:
+            geobox.aio.user.Session: 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 Session as AsyncSession
+        
+        async_user = self.user.to_async(async_client=async_client)
+        return AsyncSession(uuid=self.uuid, data=self.data, user=async_user)

geobox/utils.py

@@ -1,5 +1,6 @@
 from urllib.parse import urlparse, parse_qs, urlencode, urlunparse
 import base64
+import os
 
 
 def xor_encode(s, key=42):
@@ -8,6 +9,39 @@ def xor_encode(s, key=42):
     return encoded_bytes.decode('utf-8')
 
 
+def get_save_path(save_path: str = None) -> str:
+    """
+    Get the path where the file should be saved.
+
+    Args:
+        save_path (str, optional): The path to save the file.
+
+    Returns:
+        str: The path where the file is saved.
+    
+    Raises:
+        ValueError: If save_path does not end with a '/'.
+    """
+    # If save_path is provided, check if it ends with a '/'
+    if save_path and save_path.endswith('/'):
+        return f'{save_path}'
+    
+    if save_path and not save_path.endswith('/'):
+        raise ValueError("save_path must end with a '/'")
+    
+    return os.getcwd() + '/'
+
+
+def get_unique_filename(save_path: str, file_name: str) -> str:
+    base, ext = os.path.splitext(file_name)
+    counter = 1
+    new_file = f"{save_path}{base}({counter}){ext}"
+    while os.path.exists(new_file):
+        new_file = f"{save_path}{base}({counter}){ext}"
+        counter += 1
+    return new_file
+
+
 def clean_data(data: dict) -> dict:
     """
     Cleans the input data by removing keys with None values.

geobox/vectorlayer.py

@@ -17,6 +17,8 @@ if TYPE_CHECKING:
     from .user import User
     from .file import File
     from .attachment import Attachment
+    from .aio import AsyncGeoboxClient
+    from .aio.vectorlayer import VectorLayer as AsyncVectorLayer
 
 
 class VectorLayer(Base):
@@ -337,6 +339,16 @@ class VectorLayer(Base):
     def make_permanent(self) -> None:
         """
         Make the layer permanent.
+
+        Returns:
+            None
+
+        Example:
+            >>> from geobox import GeoboxClient
+            >>> from geobox.vectorlayer import VectorLayer
+            >>> client = GeoboxClient()
+            >>> layer = VectorLayer.get_vector(api=client, uuid="12345678-1234-5678-1234-567812345678")
+            >>> layer.make_permanent()
         """
         endpoint = urljoin(self.endpoint, 'makePermanent/')
         response = self.api.post(endpoint, is_json=False)
@@ -543,7 +555,7 @@ class VectorLayer(Base):
         Get a specific field by its name.
         
         Args:
-            name (str, optional): The name of the field to retrieve.
+            name (str): The name of the field to retrieve.
 
         Returns:
             Field: The requested field instance.
@@ -1003,7 +1015,7 @@ class VectorLayer(Base):
 
     def get_tile_pbf_url(self, x: int = '{x}', y: int = '{y}', z: int = '{z}') -> str:
         """
-        Get a vector tile for the layer.
+        Get a vector tile pbf url for the layer.
         
         Args:
             x (int, optional): X coordinate of the tile.
@@ -1062,6 +1074,25 @@ class VectorLayer(Base):
             >>> setting = layer.setting
         """
         return super()._get_settings(endpoint=self.endpoint)
+    
+
+    def update_settings(self, settings: Dict) -> Dict:
+        """
+        Update the settings
+
+        settings (Dict): settings dictionary
+
+        Returns:
+            Dict: updated settings
+
+        Example:
+            >>> from geobox import GeoboxClient
+            >>> client = GeoboxClient()
+            >>> layer1 = client.get_vector(uuid="12345678-1234-5678-1234-567812345678")
+            >>> layer2 = client.get_vector(uuid="12345678-1234-5678-1234-567812345678")
+            >>> layer1.update_settings(layer2.settings)
+        """
+        return super()._set_settings(self.endpoint, settings)  
 
 
     def set_settings(self, **kwargs) -> Dict:
@@ -1292,7 +1323,7 @@ class VectorLayer(Base):
             >>> from geobox.vectorlayer import VectorLayer
             >>> client = GeoboxClient()
             >>> layer = VectorLayer.get_vector(api=client, uuid="12345678-1234-5678-1234-567812345678")
-            >>> file = client.get_files()[0]
+            >>> file = client.get_file(uuid="12345678-1234-5678-1234-567812345678")
             >>> layer.create_attachment(name='test', loc_x=10, loc_y=10, file=file)
         """
         from .attachment import Attachment
@@ -1305,4 +1336,28 @@ class VectorLayer(Base):
                                             file=file,
                                             feature=feature,
                                             display_name=display_name,
-                                            description=description)
+                                            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:
+            geobox.aio.vectorlayer.VectorLayer: 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 VectorLayer as AsyncVectorLayer
+
+        return AsyncVectorLayer(api=async_client, uuid=self.uuid, layer_type=self.layer_type, data=self.data)

geobox/version.py

@@ -5,6 +5,8 @@ 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):
 
@@ -246,4 +248,26 @@ class VectorLayerVersion(Base):
         }
         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:
+            geobox.aio.version.VectorLayerVersion: 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 VectorLayerVersion as AsyncVectorLayerVersion
+
+        return AsyncVectorLayerVersion(api=async_client, uuid=self.uuid, data=self.data)

geobox/view.py

@@ -11,17 +11,12 @@ if TYPE_CHECKING:
     from .task import Task
     from .file import File
     from .attachment import Attachment
-
+    from .aio import AsyncGeoboxClient
+    from .aio.view import VectorLayerView as AsyncVectorLayerView 
 
 
 class VectorLayerView(VectorLayer):
-    """
-    A class representing a vector layer view in Geobox.
 
-    This class provides functionality to create, manage, and manipulate vector layer views.
-    It supports various operations including CRUD operations on views, as well as advanced operations like getting fields, features, and sharing views.
-    It also provides properties to access the view data, and a method to update the view.
-    """
     BASE_ENDPOINT = 'vectorLayerViews/'
 
     def __init__(self, 
@@ -78,7 +73,7 @@ class VectorLayerView(VectorLayer):
             api (GeoboxClient): The GeoboxClient instance for making requests.
 
         Keyword Args:
-            layer_id(int): The id of the layer.
+            layer_id(int): The id of the source vector layer.
             include_settings(bool): Whether to include the settings of the layer. default is 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.
@@ -251,9 +246,9 @@ class VectorLayerView(VectorLayer):
             >>> from geobox.view import VectorLayerView
             >>> client = GeoboxClient()
             >>> view = VectorLayerView.get_view(client, uuid="12345678-1234-5678-1234-567812345678")
-            >>> view.update_view(name="new_name")
-            >>> view.update_view(display_name="new_display_name")
-            >>> view.update_view(description="new_description")
+            >>> view.update(name="new_name")
+            >>> view.update(display_name="new_display_name")
+            >>> view.update(description="new_description")
         """
         return super().update(name=kwargs.get('name'), display_name=kwargs.get('display_name'), description=kwargs.get('description'))
     
@@ -508,7 +503,8 @@ class VectorLayerView(VectorLayer):
             NotFoundError: If the feature with the specified ID is not found.
 
         Example:
-            >>> from geobox import GeoboxClient, VectorLayerView
+            >>> from geobox import GeoboxClient
+            >>> from geobox.view import VectorLayerView
             >>> client = GeoboxClient()
             >>> view = VectorLayerView.get_view(client, uuid="12345678-1234-5678-1234-567812345678")
             >>> feature = view.get_feature(id=1)
@@ -665,9 +661,9 @@ class VectorLayerView(VectorLayer):
                                        bbox, out_srid, zipped, feature_ids, bbox_srid, q, fields)
 
     
-    def get_tile_pbf_url(self, x: int, y: int, z: int) -> str:
+    def get_tile_pbf_url(self, x: int = '{x}', y: int = '{y}', z: int = '{z}') -> str:
         """
-        Get a vector tile for the layer.
+        Get a vector tile pbf url for the view.
         
         Args:
             x (int): X coordinate of the tile.
@@ -722,6 +718,25 @@ class VectorLayerView(VectorLayer):
         return super().settings
 
 
+    def update_settings(self, settings: Dict) -> Dict:
+        """
+        Update the settings
+
+        settings (Dict): settings dictionary
+
+        Returns:
+            Dict: updated settings
+
+        Example:
+            >>> from geobox import GeoboxClient
+            >>> client = GeoboxClient()
+            >>> view1 = client.get_view(uuid="12345678-1234-5678-1234-567812345678")
+            >>> view2 = client.get_view(uuid="12345678-1234-5678-1234-567812345678")
+            >>> view1.update_settings(view2.settings)
+        """
+        return super().update_settings(settings) 
+
+
     def set_settings(self, **kwargs) -> Dict:
         """
         Set the settings of the Vector Layer.
@@ -940,4 +955,28 @@ class VectorLayerView(VectorLayer):
                                             file=file,
                                             feature=feature,
                                             display_name=display_name,
-                                            description=description)
+                                            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:
+            geobox.aio.view.VectorLayerView: 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 VectorLayerView as AsyncVectorLayerView
+
+        return AsyncVectorLayerView(api=async_client, uuid=self.uuid, layer_type=self.layer_type, data=self.data)

geobox/workflow.py

@@ -5,6 +5,8 @@ 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):
 
@@ -20,7 +22,7 @@ class Workflow(Base):
         Args:
             api (GeoboxClient): The GeoboxClient instance for making requests.
             uuid (str): The unique identifier for the workflow.
-            data (Dict): The data of the workflow.
+            data (Dict): The response data of the workflow.
         """
         super().__init__(api, uuid=uuid, data=data)
 
@@ -312,3 +314,27 @@ 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:
+            geobox.aio.workflow.Workflow: 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 Workflow as AsyncWorkflow
+
+        return AsyncWorkflow(api=async_client, uuid=self.uuid, data=self.data)

{geobox-1.4.1.dist-info → geobox-2.0.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: geobox
-Version: 1.4.1
+Version: 2.0.0
 Summary: SDK for Geobox's APIs
 Author-email: Hamid Heydari <heydari.h62@gmail.com>
 License: MIT
@@ -17,11 +17,14 @@ Requires-Dist: pyproj; extra == "geometry"
 Provides-Extra: tqdm
 Requires-Dist: tqdm; extra == "tqdm"
 Requires-Dist: ipywidgets; extra == "tqdm"
+Provides-Extra: async
+Requires-Dist: aiohttp; extra == "async"
 Provides-Extra: all
 Requires-Dist: shapely; extra == "all"
 Requires-Dist: pyproj; extra == "all"
 Requires-Dist: tqdm; extra == "all"
 Requires-Dist: ipywidgets; extra == "all"
+Requires-Dist: aiohttp; extra == "all"
 Dynamic: license-file
 
 [<img width="200" alt="Geobox logo" src="https://www.geobox.ir/wp-content/uploads/2022/05/geologo-slider.png">](https://www.geobox.ir/)

geobox-2.0.0.dist-info/RECORD

@@ -0,0 +1,68 @@
+geobox/__init__.py,sha256=ne0OfIpHDw_RiSuNmk1APBL66jAYXXPn_FAKHzkBrRM,1895
+geobox/api.py,sha256=zGlroMvfb_mnFQXCDJTpNYYecIE-IAL2vXBVpxCHq2U,105298
+geobox/apikey.py,sha256=p1kmnpjIa41vVKrz2nApWFQltorv68MNawtIWz5Ja0k,8562
+geobox/attachment.py,sha256=kbTmEayMf66f7gIS8uhD36SdnQrl1Nq_DRXjBdCeXDI,13026
+geobox/base.py,sha256=-7Qsxw7OzgtFygKqaDVB__HxmUqA521XGxj9ibtTmO8,12967
+geobox/basemap.py,sha256=998m2lpgESIGsJuADWFnqg5eShskCtlp6Qcri4IM6Hg,5587
+geobox/dashboard.py,sha256=iBK1ZFl3pM95q0lFAeRDnuk2vhhfm9-zBV0YOTKXAu0,12821
+geobox/enums.py,sha256=Ur8zbUjfx09oxXb-uzwFfDT_Nt8I4AP5pFQKJ9bxVxI,6204
+geobox/exception.py,sha256=jvpnv0M2Ck1FpxHTL_aKYWxGvLnCQ3d9vOrMIktjw1U,1507
+geobox/feature.py,sha256=PphGJLSya2FR-JSaC7lE0YE-nf2A2wHPTCG3Rj6iz9Y,19239
+geobox/field.py,sha256=ZNbuf3ayemyguVee10yCKH4aq62xUEmY--qQLTeRz4Q,10897
+geobox/file.py,sha256=RkRlHORGa1ybWFrK-QFavEPiRrcU5OBhNwfcc_gpfzE,20217
+geobox/layout.py,sha256=a0lkrl2ondvgOM-BwRuMgEmzo-C7frFJzC7MuX2MNl8,12348
+geobox/log.py,sha256=-BHQdXooUKD-ETslxHuv9SGhlk8yzzRizSSiK404Y0I,5007
+geobox/map.py,sha256=CGorSxO5vuiOtmwUs3Mk4PeOg-HF5py3sRo6ahx9GF8,38074
+geobox/model3d.py,sha256=e_d_E7yj-Ria3oJm9V14vfXV-g1iMHa7u7sl9Or4FlA,14938
+geobox/mosaic.py,sha256=Ceh_kleRlZqBSDTTV27iwahG-TGsdpVzUyXcB3dbJIo,25128
+geobox/plan.py,sha256=f7ciVE_VKM7onuzE3bGK63XxxrtfUsMv16oImyDgZ3c,13061
+geobox/query.py,sha256=C0tqAEjqExb5a_0kO9mr63i62DobKwwDWphNQTU6WTE,25499
+geobox/raster.py,sha256=YSO-Qc73PWu2jIZdoF2xfqgVlBKGgAiYUhswjbgBfrY,31098
+geobox/route.py,sha256=cKZTTHBHM8woWbhHIpCvrRX_doJcTkGktouee0z7oG0,2723
+geobox/scene.py,sha256=iUkMxH4YqPk3vCIQq1uAZgQGWUvtujKBylUWcmUpQkM,12356
+geobox/settings.py,sha256=ue6vZYYIirisYBwnuTsZnV7fG0jOQampX1xroC5lpdk,6856
+geobox/task.py,sha256=xc7UyyRm3cmzH1uznOZ-osRGSAdVufIQsmeVuoJ-IWs,14505
+geobox/tile3d.py,sha256=nEFs2TuzJFC9k__rPlkWwL6s-WjIsyQZS5FEhmfsck0,12093
+geobox/tileset.py,sha256=wk0vSSON0DHiO6NzaScZnmu7d424jFCgNk0kJLDAtA8,25041
+geobox/usage.py,sha256=47nR-JDA3yfsK-o3eWSYA7FeDVJNPIIfvsRTGkfNv9A,9215
+geobox/user.py,sha256=GFQTw8EwLcyf-AMatmejtrgnSHB6Qg-ctE5YrzYIMEQ,17509
+geobox/utils.py,sha256=JmlRqDVIo0vBikzH1XakRrCrEIfLA7_eTJnBWBvGhJI,2243
+geobox/vectorlayer.py,sha256=_i1RdIw_P9BglnsERDLRxDRz6RU3tP7kVjFnRGepfyk,58622
+geobox/version.py,sha256=6IO8AHVTbS4z-cwaqqPt0o3ggwmskimKUoUoeFzx5UE,10560
+geobox/view.py,sha256=fUWOC_ZJ5mg6T0jHYJ5-rb7k2blI_EWT_lu4yE-cD_c,42333
+geobox/workflow.py,sha256=Gi4AJlsvo_SFY3Ptgp_3sg_f37eIZNL2whn2yMW8Dkg,12666
+geobox/aio/__init__.py,sha256=EO8VP0d5JPPZH1o1CBdwSMkPZOpyGPK0v9UbIvf6g7w,1906
+geobox/aio/api.py,sha256=NIVHOKNA_UWD4V-prLmzxEQOFhkHJL4LW0fnXbn53BM,112430
+geobox/aio/apikey.py,sha256=J_4XqTJ3PZUxsOqR1F-WIbpWzIihX32Y2sjPdSEUboY,9232
+geobox/aio/attachment.py,sha256=EXBdtlb5aKlnm5GHWDfX67v0mFON5gDBtF13rknETYM,13644
+geobox/aio/base.py,sha256=-B56CC7uMbb84DzT1YzytpOwalFRZ8mAtaVajcE4cNI,9189
+geobox/aio/basemap.py,sha256=HFwvNKMQVB1RJ9hGrCHiG_AtMGiy3Z1WStmHqrhFGeU,5950
+geobox/aio/dashboard.py,sha256=xp1SydoQ2zEu1afFcGFF4jRwbOD1CUyuflALpGukL1g,13588
+geobox/aio/feature.py,sha256=wQgfpzo9gtR8XsvAZi6IAna3mZVqYf9xqnl4ZV_lWY4,20186
+geobox/aio/field.py,sha256=shZFodWTtoczAfs0n5JZ6kCVqD2r6dLQP_27tJ6jSSw,11568
+geobox/aio/file.py,sha256=ZabKAvnxfiJFWODPm5cMbjTR9LNATdPR7aU0HeSSI70,21316
+geobox/aio/layout.py,sha256=5YqyqhbOKoZDAqFOvmdxtlUiauOqzZ-ZNmc1wIU00vE,13056
+geobox/aio/log.py,sha256=dlKAq9e7rdsEDZ9lI3GjZe8DTQNrta-BfBJKNkHwgGs,5299
+geobox/aio/map.py,sha256=cOSCSVF3ERWXkMnneGLUryNZsXiScerLzmDw7K81uNE,40441
+geobox/aio/model3d.py,sha256=Gg1fbfNILMeLjBwS6vxcPx-AJWdriIGKtkJ6b06GxsE,15959
+geobox/aio/mosaic.py,sha256=wqXzrK9C-rZeMVamurqZj5Og6rSruvXBssnYfpWmt-g,27029
+geobox/aio/plan.py,sha256=pUBfmd-AfzAn7ejv3x2mp3cYr5mM9nMMdO-YDh1JDVY,13690
+geobox/aio/query.py,sha256=iLHt2MIzCP8ayUCahWMy1yPR0e9w9wZutNzp2M-FisA,27011
+geobox/aio/raster.py,sha256=dPCfoD-OP5o4lgX87edYDmOgl4R-APyaNcbU6H5Y13A,33084
+geobox/aio/route.py,sha256=YCTcAfaSFE429fpL4eIb2VrBEdBo6SmolPomVM1F66A,2854
+geobox/aio/scene.py,sha256=cxQdFkFD-Z-ZWJyhrW_W53DyUVILmEQgJoFaG3KU_FI,13130
+geobox/aio/settings.py,sha256=q1B2iZf0ekl21cByP5P9Z0ivWCDxw8UNi16NOXm76qA,7042
+geobox/aio/task.py,sha256=6TEwrBqpT3YWRLo9_c0U9WFs1SHsX3h5Xe0m7XbjHR4,15329
+geobox/aio/tile3d.py,sha256=QWYdmMQSlWqztflLTqFDqQaynkgRLoVZPF4NlwOMqDg,12935
+geobox/aio/tileset.py,sha256=LUsCtafwFCYqG41vNNlbe3GyWXjJ1_UYV-4o7-w-Xk8,27379
+geobox/aio/usage.py,sha256=AC2TPsomnK-W7EbXOGP6Flkkeh7n4KRCJmBuTdIofQo,9776
+geobox/aio/user.py,sha256=k3JCPQpwiIzJBP6xvKsPkueElW6e1i9a-odNAOIZB9U,18622
+geobox/aio/vectorlayer.py,sha256=1635i0Vc4mvcYmgTx53sanpZJYLe5Ho4YsO2pEPH23A,62087
+geobox/aio/version.py,sha256=HAKB9jHGZ0-EirNg9aNwYYPVFT3YOYQ0JNCxP7Nvk9g,11201
+geobox/aio/view.py,sha256=peTf__JNMqdiTb6VQeuhj_RqljzcskbwwDaHhQ3Cf9w,45353
+geobox/aio/workflow.py,sha256=itqTO7XlO1YmLd7pnS5BHhaC48ykEmYDXPs-2hDxey4,13411
+geobox-2.0.0.dist-info/licenses/LICENSE,sha256=AvFB7W94sJYKLDhBxLRshL3upexCOG8HQY_1JibB96w,1063
+geobox-2.0.0.dist-info/METADATA,sha256=wrMvTlsryT7tzWgl7NcLvaeVn8yxPB26qEgz5dijo68,2760
+geobox-2.0.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+geobox-2.0.0.dist-info/top_level.txt,sha256=ppXH8Bu2mlB-pLQ6lsoWEm2Gr6wZx1uzkhetsYA5ins,7
+geobox-2.0.0.dist-info/RECORD,,