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

geobox/field.py

@@ -8,17 +8,16 @@ from .enums import FieldType
 if TYPE_CHECKING:
     from .api import GeoboxClient
     from .vectorlayer import VectorLayer
-    from .aio import AsyncGeoboxClient
-    from .aio.field import AsyncField
 
 
 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 +81,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 +266,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 +285,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,31 +300,5 @@ class Field(Base):
         if list_domain:
             self.domain['items'] = {**self.domain['items'], **list_domain}
 
-        self.save()
+        self.update(domain=self.domain)
         return self.domain
-
-
-    def to_async(self, async_client: 'AsyncGeoboxClient') -> 'AsyncField':
-        """
-        Switch to async version of the field instance to have access to the async methods
-
-        Args:
-            async_client (AsyncGeoboxClient): The async version of the GeoboxClient instance for making requests.
-
-        Returns:
-            AsyncField: the async instance of the field.
-
-        Example:
-            >>> from geobox import Geoboxclient
-            >>> from geobox.aio import AsyncGeoboxClient
-            >>> from geobox.field import Field
-            >>> client = GeoboxClient()
-            >>> layer = client.get_vector(uuid="12345678-1234-5678-1234-567812345678")
-            >>> field = layer.get_field(name='test')
-            >>> async with AsyncGeoboxClient() as async_client:
-            >>>     async_field = field.to_async(async_client)
-        """
-        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)

geobox/file.py

@@ -15,8 +15,6 @@ from .feature import Feature
 if TYPE_CHECKING:
     from . import GeoboxClient 
     from .user import User
-    from .aio import AsyncGeoboxClient
-    from .aio.file import AsyncFile
 
 
 class File(Base):
@@ -491,27 +489,3 @@ class File(Base):
             'limit': limit
         }
         return super()._get_shared_users(self.endpoint, params)
-
-
-    def to_async(self, async_client: 'AsyncGeoboxClient') -> 'AsyncFile':
-        """
-        Switch to async version of the file instance to have access to the async methods
-
-        Args:
-            async_client (AsyncGeoboxClient): The async version of the GeoboxClient instance for making requests.
-
-        Returns:
-            AsyncFile: the async instance of the file.
-
-        Example:
-            >>> from geobox import Geoboxclient
-            >>> from geobox.aio import AsyncGeoboxClient
-            >>> from geobox.file import File
-            >>> client = GeoboxClient()
-            >>> file = File.get_file(client, uuid="12345678-1234-5678-1234-567812345678")
-            >>> async with AsyncGeoboxClient() as async_client:
-            >>>     async_file = file.to_async(async_client)
-        """
-        from .aio.file import AsyncFile
-
-        return AsyncFile(api=async_client, uuid=self.uuid, data=self.data)

geobox/layout.py

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

geobox/log.py

@@ -5,8 +5,6 @@ from .base import Base
 if TYPE_CHECKING:
     from . import GeoboxClient
     from .user import User
-    from .aio import AsyncGeoboxClient
-    from .aio.log import AsyncLog
 
 
 class Log(Base):
@@ -118,27 +116,3 @@ class Log(Base):
             >>> log.user
         """
         return self.api.get_user(self.owner_id)
-    
-
-    def to_async(self, async_client: 'AsyncGeoboxClient') -> 'AsyncLog':
-        """
-        Switch to async version of the log instance to have access to the async methods
-
-        Args:
-            async_client (AsyncGeoboxClient): The async version of the GeoboxClient instance for making requests.
-
-        Returns:
-            AsyncLog: the async instance of the log.
-
-        Example:
-            >>> from geobox import Geoboxclient
-            >>> from geobox.aio import AsyncGeoboxClient
-            >>> from geopox.log import Log
-            >>> client = GeoboxClient()
-            >>> log = Log.get_logs(client)[0]
-            >>> async with AsyncGeoboxClient() as async_client:
-            >>>     async_log = log.to_async(async_client)
-        """
-        from .aio.log import AsyncLog
-
-        return AsyncLog(api=async_client, log_id=self.log_id, data=self.data)

geobox/map.py

@@ -12,8 +12,6 @@ if TYPE_CHECKING:
     from .user import User
     from .task import Task
     from .attachment import Attachment
-    from .aio import AsyncGeoboxClient
-    from .aio.map import Map as AsyncMap
 
 
 class Map(Base):
@@ -1006,27 +1004,3 @@ class Map(Base):
                                             feature=feature,
                                             display_name=display_name,
                                             description=description)
-    
-
-    def to_async(self, async_client: 'AsyncGeoboxClient') -> 'AsyncMap':
-        """
-        Switch to async version of the map instance to have access to the async methods
-
-        Args:
-            async_client (AsyncGeoboxClient): The async version of the GeoboxClient instance for making requests.
-
-        Returns:
-            AsyncMap: the async instance of the map.
-
-        Example:
-            >>> from geobox import Geoboxclient
-            >>> from geobox.aio import AsyncGeoboxClient
-            >>> from geobox.map import Map
-            >>> client = GeoboxClient()
-            >>> map = Map.get_map(client, uuid="12345678-1234-5678-1234-567812345678")
-            >>> async with AsyncGeoboxClient() as async_client:
-            >>>     async_map = map.to_async(async_client)
-        """
-        from .aio.map import AsyncMap
-
-        return AsyncMap(api=async_client, uuid=self.uuid, data=self.data)

geobox/model3d.py

@@ -11,8 +11,6 @@ from .utils import get_save_path
 if TYPE_CHECKING:
     from . import GeoboxClient
     from .user import User
-    from .aio import AsyncGeoboxClient
-    from .aio.model3d import AsyncModel
 
 
 class Model(Base):
@@ -385,27 +383,3 @@ class Model(Base):
             'limit': limit
         }
         return super()._get_shared_users(self.endpoint, params)
-
-
-    def to_async(self, async_client: 'AsyncGeoboxClient') -> 'AsyncModel':
-        """
-        Switch to async version of the 3d model instance to have access to the async methods
-
-        Args:
-            async_client (AsyncGeoboxClient): The async version of the GeoboxClient instance for making requests.
-
-        Returns:
-            AsyncModel: the async instance of the 3d model.
-
-        Example:
-            >>> from geobox import Geoboxclient
-            >>> from geobox.aio import AsyncGeoboxClient
-            >>> from geobox.model3d import Model
-            >>> client = GeoboxClient()
-            >>> model = Model.get_model(client, uuid="12345678-1234-5678-1234-567812345678")
-            >>> async with AsyncGeoboxClient() as async_client:
-            >>>     async_model = model.to_async(async_client)
-        """
-        from .aio.model3d import AsyncModel
-
-        return AsyncModel(api=async_client, uuid=self.uuid, data=self.data)

geobox/mosaic.py

@@ -8,8 +8,6 @@ if TYPE_CHECKING:
     from . import GeoboxClient
     from .user import User
     from .task import Task
-    from .aio import AsyncGeoboxClient
-    from .aio.mosaic import AsyncMosaic
 
 
 class Mosaic(Raster):
@@ -670,27 +668,3 @@ class Mosaic(Raster):
             >>> mosaic.cache_size
         """
         return super().cache_size
-    
-
-    def to_async(self, async_client: 'AsyncGeoboxClient') -> 'AsyncMosaic':
-        """
-        Switch to async version of the mosaic instance to have access to the async methods
-
-        Args:
-            async_client (AsyncGeoboxClient): The async version of the GeoboxClient instance for making requests.
-
-        Returns:
-            AsyncMosaic: the async instance of the mosaic.
-
-        Example:
-            >>> from geobox import Geoboxclient
-            >>> from geobox.aio import AsyncGeoboxClient
-            >>> from geobox.mosaic import Mosaic
-            >>> client = GeoboxClient()
-            >>> mosaic = Mosaic.get_mosaic(client, uuid="12345678-1234-5678-1234-567812345678")
-            >>> async with AsyncGeoboxClient() as async_client:
-            >>>     async_mosaic = mosaic.to_async(async_client)
-        """
-        from .aio.mosaic import AsyncMosaic
-
-        return AsyncMosaic(api=async_client, uuid=self.uuid, data=self.data)

geobox/plan.py

@@ -5,8 +5,7 @@ from .base import Base
 
 if TYPE_CHECKING:
     from . import GeoboxClient
-    from .aio import AsyncGeoboxClient
-    from .aio.plan import AsyncPlan
+
 
 class Plan(Base):
 
@@ -288,27 +287,3 @@ class Plan(Base):
         """
         super()._delete(self.endpoint)
         self.plan_id = None
-
-
-    def to_async(self, async_client: 'AsyncGeoboxClient') -> 'AsyncPlan':
-        """
-        Switch to async version of the plan instance to have access to the async methods
-
-        Args:
-            async_client (AsyncGeoboxClient): The async version of the GeoboxClient instance for making requests.
-
-        Returns:
-            AsyncPlan: the async instance of the plan.
-
-        Example:
-            >>> from geobox import Geoboxclient
-            >>> from geobox.aio import AsyncGeoboxClient
-            >>> from geobox.plan import Plan
-            >>> client = GeoboxClient()
-            >>> plan = Plan.get_plan(client, plan_id=1)
-            >>> async with AsyncGeoboxClient() as async_client:
-            >>>     async_plan = plan.to_async(async_client)
-        """
-        from .aio.plan import AsyncPlan
-
-        return AsyncPlan(api=async_client, plan_id=self.plan_id, data=self.data)

geobox/query.py

@@ -9,8 +9,7 @@ from .enums import QueryResultType, QueryGeometryType, QueryParamType
 if TYPE_CHECKING:
     from . import GeoboxClient
     from .user import User
-    from .aio import AsyncGeoboxClient
-    from .aio.query import AsyncQuery
+
 
 class Query(Base):
 
@@ -666,27 +665,3 @@ class Query(Base):
         response = self.api.post(endpoint, data)
         task = Task.get_task(self.api, response.get('task_id'))
         return task
-
-
-    def to_async(self, async_client: 'AsyncGeoboxClient') -> 'AsyncQuery':
-        """
-        Switch to async version of the query instance to have access to the async methods
-
-        Args:
-            async_client (AsyncGeoboxClient): The async version of the GeoboxClient instance for making requests.
-
-        Returns:
-            AsyncQuery: the async instance of the query.
-
-        Example:
-            >>> from geobox import Geoboxclient
-            >>> from geobox.aio import AsyncGeoboxClient
-            >>> from geobox.query import Query
-            >>> client = GeoboxClient()
-            >>> query = Query.get_query(client, uuid="12345678-1234-5678-1234-567812345678")
-            >>> async with AsyncGeoboxClient() as async_client:
-            >>>     async_query = query.to_async(async_client)
-        """
-        from .aio.query import AsyncQuery
-
-        return AsyncQuery(api=async_client, uuid=self.uuid, data=self.data)

geobox/raster.py

@@ -5,20 +5,14 @@ import mimetypes
 import requests
 import sys
 
-from geobox.field import Field
-
 from .base import Base
 from .utils import clean_data, join_url_params
 from .task import Task
-from .vectorlayer import VectorLayer
-from .view import VectorLayerView
-from .enums import PolygonizeConnectivity, AnalysisResampleMethod, SlopeUnit, AnalysisAlgorithm, AnalysisDataType, RangeBound, DistanceUnit
 
 if TYPE_CHECKING:
     from . import GeoboxClient 
     from .user import User
-    from .aio import AsyncGeoboxClient
-    from .aio.raster import AsyncRaster
+
 
 class Raster(Base):
 
@@ -844,30 +838,6 @@ class Raster(Base):
         return super()._cache_size(self.endpoint)
 
 
-    def to_async(self, async_client: 'AsyncGeoboxClient') -> 'AsyncRaster':
-        """
-        Switch to async version of the raster instance to have access to the async methods
-
-        Args:
-            async_client (AsyncGeoboxClient): The async version of the GeoboxClient instance for making requests.
-
-        Returns:
-            AsyncRaster: the async instance of the raster.
-
-        Example:
-            >>> from geobox import Geoboxclient
-            >>> from geobox.aio import AsyncGeoboxClient
-            >>> from geobox.raster import Raster
-            >>> client = GeoboxClient()
-            >>> raster = Raster.get_raster(client, uuid="12345678-1234-5678-1234-567812345678")
-            >>> async with AsyncGeoboxClient() as async_client:
-            >>>     async_raster = raster.to_async(async_client)
-        """
-        from .aio.raster import AsyncRaster
-
-        return AsyncRaster(api=async_client, uuid=self.uuid, data=self.data)
-
-
     def profile(self,
         polyline: List,
         number_of_samples: int = 100,

geobox/scene.py

@@ -1,13 +1,11 @@
 from typing import List, Dict, Optional, TYPE_CHECKING, Union
-from urllib.parse import urljoin
 
 from .base import Base
 
 if TYPE_CHECKING:
     from . import GeoboxClient
     from .user import User 
-    from .aio import AsyncGeoboxClient
-    from .aio.scene import AsyncScene
+
 
 class Scene(Base):
 
@@ -315,27 +313,3 @@ class Scene(Base):
             'limit': limit
         }
         return super()._get_shared_users(self.endpoint, params)
-    
-
-    def to_async(self, async_client: 'AsyncGeoboxClient') -> 'AsyncScene':
-        """
-        Switch to async version of the scene instance to have access to the async methods
-
-        Args:
-            async_client (AsyncGeoboxClient): The async version of the GeoboxClient instance for making requests.
-
-        Returns:
-            AsyncScene: the async instance of the scene.
-
-        Example:
-            >>> from geobox import Geoboxclient
-            >>> from geobox.aio import AsyncGeoboxClient
-            >>> from geobox.scene import Scene
-            >>> client = GeoboxClient()
-            >>> scene = Scene.get_scene(client, uuid="12345678-1234-5678-1234-567812345678")
-            >>> async with AsyncGeoboxClient() as async_client:
-            >>>     async_scene = scene.to_async(async_client)
-        """
-        from .aio.scene import AsyncScene
-
-        return AsyncScene(api=async_client, uuid=self.uuid, data=self.data)

geobox/settings.py

@@ -1,4 +1,4 @@
-from typing import List, Dict, Optional, TYPE_CHECKING
+from typing import Dict, Optional, TYPE_CHECKING
 from urllib.parse import urljoin, urlencode
 
 from .base import Base
@@ -8,8 +8,6 @@ from .enums import MaxLogPolicy, InvalidDataPolicy, LoginFailurePolicy, MaxConcu
 
 if TYPE_CHECKING:
     from . import GeoboxClient
-    from .aio import AsyncGeoboxClient
-    from .aio.settings import AsyncSystemSettings
 
 
 class SystemSettings(Base):
@@ -167,29 +165,3 @@ class SystemSettings(Base):
             
         }
         return super()._update(self.BASE_ENDPOINT, data)
-    
-
-    def to_async(self, async_client: 'AsyncGeoboxClient') -> 'AsyncSystemSettings':
-        """
-        Switch to async version of the system settings instance to have access to the async methods
-
-        Args:
-            async_client (AsyncGeoboxClient): The async version of the GeoboxClient instance for making requests.
-
-        Returns:
-            AsyncSystemSettings: the async instance of the system settings.
-
-        Example:
-            >>> from geobox import Geoboxclient
-            >>> from geobox.aio import AsyncGeoboxClient
-            >>> from geobox.setting import SystemSettings
-            >>> client = GeoboxClient()
-            >>> settings = SystemSetting.get_system_settings(client)
-            or
-            >>> settings = client.get_system_settings()
-            >>> async with AsyncGeoboxClient() as async_client:
-            >>>     async_settings = settings.to_async(async_client)
-        """
-        from .aio.settings import AsyncSystemSettings
-
-        return AsyncSystemSettings(api=async_client, data=self.data)