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

geobox/aio/layout.py

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

geobox/aio/log.py

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

geobox/aio/map.py

@@ -12,8 +12,6 @@ if TYPE_CHECKING:
     from .user import AsyncUser
     from .task import AsyncTask
     from .attachment import AsyncAttachment
-    from ..api import GeoboxClient
-    from ..map import Map
 
 
 class AsyncMap(AsyncBase):
@@ -1007,27 +1005,3 @@ class AsyncMap(AsyncBase):
             feature=feature,
             display_name=display_name,
             description=description)
-
-
-    def to_sync(self, sync_client: 'GeoboxClient') -> 'Map':
-        """
-        Switch to sync version of the map instance to have access to the sync methods
-
-        Args:
-            sync_client (GeoboxClient): The sync version of the GeoboxClient instance for making requests.
-
-        Returns:
-            Map: the sync instance of the map.
-
-        Example:
-            >>> from geobox import Geoboxclient
-            >>> from geobox.aio import AsyncGeoboxClient
-            >>> from geobox.aio.map import AsyncMap
-            >>> client = GeoboxClient()
-            >>> async with AsyncGeoboxClient() as async_client:
-            >>>     map = await AsyncMap.get_map(async_client, uuid="12345678-1234-5678-1234-567812345678")
-            >>>     sync_map = map.to_sync(client)
-        """
-        from ..map import Map
-
-        return Map(api=sync_client, uuid=self.uuid, data=self.data)

geobox/aio/model3d.py

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

geobox/aio/mosaic.py

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

geobox/aio/plan.py

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

geobox/aio/query.py

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

geobox/aio/raster.py

@@ -12,8 +12,6 @@ from ..utils import clean_data, join_url_params
 if TYPE_CHECKING:
     from . import AsyncGeoboxClient
     from .user import AsyncUser
-    from ..api import GeoboxClient
-    from ..raster import Raster
 
 
 class AsyncRaster(AsyncBase):
@@ -844,30 +842,6 @@ class AsyncRaster(AsyncBase):
         return await super()._cache_size(self.endpoint)
 
 
-    def to_sync(self, sync_client: 'GeoboxClient') -> 'Raster':
-        """
-        Switch to sync version of the raster instance to have access to the sync methods
-
-        Args:
-            sync_client (GeoboxClient): The sync version of the GeoboxClient instance for making requests.
-
-        Returns:
-            Raster: the sync instance of the raster.
-
-        Example:
-            >>> from geobox import Geoboxclient
-            >>> from geobox.aio import AsyncGeoboxClient
-            >>> from geobox.aio.raster import AsyncRaster
-            >>> client = GeoboxClient()
-            >>> async with AsyncGeoboxClient() as async_client:
-            >>>     raster = await AsyncRaster.get_raster(async_client, uuid="12345678-1234-5678-1234-567812345678")
-            >>>     sync_raster = raster.to_sync(client)
-        """
-        from ..raster import Raster
-
-        return Raster(api=sync_client, uuid=self.uuid, data=self.data)
-
-
     async def profile(self,
         polyline: List,
         number_of_samples: int = 100,

geobox/aio/scene.py

@@ -5,8 +5,7 @@ from .base import AsyncBase
 if TYPE_CHECKING:
     from . import AsyncGeoboxClient
     from .user import AsyncUser
-    from ..api import GeoboxClient
-    from ..scene import Scene
+
 
 class AsyncScene(AsyncBase):
 
@@ -314,27 +313,3 @@ class AsyncScene(AsyncBase):
             'limit': limit
         }
         return await super()._get_shared_users(self.endpoint, params)
-
-
-    def to_sync(self, sync_client: 'GeoboxClient') -> 'Scene':
-        """
-        Switch to sync version of the scene instance to have access to the sync methods
-
-        Args:
-            sync_client (GeoboxClient): The sync version of the GeoboxClient instance for making requests.
-
-        Returns:
-            Scene: the sync instance of the scene.
-
-        Example:
-            >>> from geobox import Geoboxclient
-            >>> from geobox.aio import AsyncGeoboxClient
-            >>> from geobox.aio.scene import AsyncScene
-            >>> client = GeoboxClient()
-            >>> async with AsyncGeoboxClient() as async_client:
-            >>>     scene = await AsyncScene.get_scene(async_client, uuid="12345678-1234-5678-1234-567812345678")
-            >>>     sync_scene = scene.to_sync(client)
-        """
-        from ..scene import Scene
-
-        return Scene(api=sync_client, uuid=self.uuid, data=self.data)

geobox/aio/settings.py

@@ -7,8 +7,6 @@ from ..enums import MaxLogPolicy, InvalidDataPolicy, LoginFailurePolicy, MaxConc
 
 if TYPE_CHECKING:
     from . import AsyncGeoboxClient
-    from ..api import GeoboxClient
-    from ..settings import SystemSettings
 
 
 class AsyncSystemSettings(AsyncBase):
@@ -166,29 +164,3 @@ class AsyncSystemSettings(AsyncBase):
             
         }
         return await super()._update(self.BASE_ENDPOINT, data)
-
-
-    def to_sync(self, sync_client: 'GeoboxClient') -> 'SystemSettings':
-        """
-        Switch to sync version of the system settings instance to have access to the sync methods
-
-        Args:
-            sync_client (GeoboxClient): The sync version of the GeoboxClient instance for making requests.
-
-        Returns:
-            SystemSettings: the sync instance of the system settings.
-
-        Example:
-            >>> from geobox import Geoboxclient
-            >>> from geobox.aio import AsyncGeoboxClient
-            >>> from geobox.aio.setting import AsyncSystemSettings
-            >>> client = GeoboxClient()
-            >>> async with AsyncGeoboxClient() as async_client:
-            >>>     settings = await AsyncSystemSetting.get_system_settings(async_client)
-            or  
-            >>>     settings = await async_client.get_system_settings()
-            >>>     sync_settings = settings.to_sync(client)
-        """
-        from ..task import Task as SyncTask
-
-        return SyncTask(api=sync_client, uuid=self.uuid, data=self.data)