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

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)