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

geobox/aio/task.py

@@ -14,7 +14,6 @@ if TYPE_CHECKING:
     from .model3d import AsyncModel
     from .file import AsyncFile
     from .tile3d import AsyncTile3d
-    from ..api import GeoboxClient
     from ..task import Task
 
 logger = logging.getLogger(__name__)
@@ -379,29 +378,3 @@ class AsyncTask(AsyncBase):
             >>>     task = await client.get_task(uuid="12345678-1234-5678-1234-567812345678")
         """
         return await super()._get_detail(api, cls.BASE_ENDPOINT, uuid, factory_func=lambda api, item: AsyncTask(api, item['uuid'], item))
-
-
-    def to_sync(self, sync_client: 'GeoboxClient') -> 'Task':
-        """
-        Switch to sync version of the task instance to have access to the sync methods
-
-        Args:
-            sync_client (SyncGeoboxClient): The sync version of the GeoboxClient instance for making requests.
-
-        Returns:
-            Task: the sync instance of the task.
-
-        Example:
-            >>> from geobox import Geoboxclient
-            >>> from geobox.aio import AsyncGeoboxClient
-            >>> from geobox.aio.task import AsyncTask
-            >>> client = GeoboxClient()
-            >>> async with AsyncGeoboxClient() as async_client:
-            >>>     task = await AsyncTask.get_task(async_client, uuid="12345678-1234-5678-1234-567812345678")
-            or  
-            >>>     task = await async_client.get_task(uuid="12345678-1234-5678-1234-567812345678")
-            >>>     sync_task = task.to_sync(client)
-        """
-        from ..task import Task
-
-        return Task(api=sync_client, uuid=self.uuid, data=self.data)

geobox/aio/tile3d.py

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

geobox/aio/tileset.py

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

geobox/aio/usage.py

@@ -10,8 +10,6 @@ from ..enums import UsageScale, UsageParam
 
 if TYPE_CHECKING:
     from . import AsyncGeoboxClient
-    from ..api import GeoboxClient
-    from ..usage import Usage
 
 
 class AsyncUsage(AsyncBase):
@@ -212,33 +210,3 @@ class AsyncUsage(AsyncBase):
         })
         endpoint = f"{cls.BASE_ENDPOINT}update"
         return await api.post(endpoint, payload=data)
-
-
-    def to_sync(self, sync_client: 'GeoboxClient') -> 'Usage':
-        """
-        Switch to sync version of the usage instance to have access to the sync methods
-
-        Args:
-            sync_client (GeoboxClient): The sync version of the GeoboxClient instance for making requests.
-
-        Returns:
-            Usage: the sync instance of the usage.
-
-        Example:
-            >>> from geobox import Geoboxclient
-            >>> from geobox.aio import AsyncGeoboxClient
-            >>> from geobox.aio.usage import AsyncUsage
-            >>> client = GeoboxClient()
-            >>> async with AsyncGeoboxClient() as async_client:
-            >>>     user = await async_client.get_user()
-            >>>     usage = await AsyncUsage.get_api_usage(async_client, 
-            ...                                         resource=user, 
-            ...                                         scale=UsageScale.Day, 
-            ...                                         param=UsageParam.Calls, 
-            ...                                         days_before_now=5)
-            >>>     sync_usage = await usage.to_sync(client)
-        """
-        from ..usage import Usage
-
-        user = self.user.to_sync(sync_client)
-        return Usage(api=sync_client, user=user)

geobox/aio/user.py

@@ -8,9 +8,6 @@ from .plan import AsyncPlan
 
 if TYPE_CHECKING:
     from . import AsyncGeoboxClient
-    from ..api import GeoboxClient
-    from ..api import User
-    from ..api import Session
 
 
 class AsyncUser(AsyncBase):
@@ -399,33 +396,6 @@ class AsyncUser(AsyncBase):
         await self.api.post(endpoint)
 
 
-    def to_sync(self, sync_client: 'GeoboxClient') -> 'User':
-        """
-        Switch to sync version of the user instance to have access to the sync methods
-
-        Args:
-            sync_client (GeoboxClient): The sync version of the GeoboxClient instance for making requests.
-
-        Returns:
-            User: the async instance of the user.
-
-        Example:
-            >>> from geobox import Geoboxclient
-            >>> from geobox.aio import AsyncGeoboxClient
-            >>> from geobox.aio.user import AsyncUser
-            >>> client = GeoboxClient()
-            >>> async with AsyncGeoboxClient() as async_client:
-            >>>     user = await AsyncUser.get_user(async_client) # without user_id parameter, it gets the current user
-            or  
-            >>>     user = await async_client.get_user() # without user_id parameter, it gets the current user
-            >>>     sync_user = user.to_sync(client)
-        """
-        from ..user import User
-
-        return User(api=sync_client, user_id=self.user_id, data=self.data)
-
-
-
 class AsyncSession(AsyncBase):
     def __init__(self, uuid: str, data: Dict, user: 'AsyncUser'):
         """
@@ -475,32 +445,3 @@ class AsyncSession(AsyncBase):
             'session_uuid': self.uuid
         })
         await self.user.api.post(self.endpoint, data)
-
-
-    def to_sync(self, sync_client: 'GeoboxClient') -> 'Session':
-        """
-        Switch to sync version of the session instance to have access to the sync methods
-
-        Args:
-            sync_client (GeoboxClient): The sync version of the GeoboxClient instance for making requests.
-
-        Returns:
-            Session: the sync instance of the session.
-
-        Example:
-            >>> from geobox import Geoboxclient
-            >>> from geobox.aio import AsyncGeoboxClient
-            >>> from geobox.aio.user import AsyncUser
-            >>> client = GeoboxClient()
-            >>> async with AsyncGeoboxClient() as async_client:
-            >>>     user = await AsyncUser.get_user(async_client) # without user_id parameter, it gets the current user
-            or  
-            >>>     user = await async_client.get_user() # without user_id parameter, it gets the current user
-            >>>     sessions = await user.get_sessions()
-            >>>     session = sessions[0]
-            >>>     sync_session = session.to_sync(client)
-        """
-        from ..user import Session
-
-        sync_user = self.user.to_sync(sync_client)
-        return Session(uuid=self.uuid, data=self.data, user=sync_user)

geobox/aio/vector_tool.py

@@ -1965,4 +1965,53 @@ class AsyncVectorTool(AsyncBase):
             'srid': srid
         }
         query = await self._add_params_to_query(query_name='$xy_coordinate', inputs=inputs)
+        return await self._run_query(query=query, output_layer_name=output_layer_name)
+
+
+    async def table_to_vectorlayer(self,
+        table_uuid: str,
+        lon_field: str,
+        lat_field: str,
+        output_layer_name: Optional[str] = None,
+    ) -> Union['AsyncTask', Dict]:
+        """
+        [async] 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['AsyncTask', 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.aio import AsyncGeoboxClient
+            >>> async with AsyncGeoboxClient() as client:
+            >>>     table = await client.get_table(uuid="12345678-1234-5678-1234-567812345678")
+
+            >>>     # execution
+            >>>     result = await client.vector_tool.table_to_vectorlayer(
+            ...         table_uuid=table.uuid, 
+            ...         lon_field="lon_field_name",
+            ...         lat_field="lat_field_name",
+            ...     )
+
+            >>>     # save as layer
+            >>>     task = await 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 = await self._add_params_to_query(query_name='$tabel_to_vector_layer', inputs=inputs)
         return await self._run_query(query=query, output_layer_name=output_layer_name)

geobox/aio/vectorlayer.py

@@ -16,8 +16,6 @@ if TYPE_CHECKING:
     from .user import AsyncUser
     from .file import AsyncFile
     from .attachment import AsyncAttachment
-    from ..api import GeoboxClient
-    from ..vectorlayer import VectorLayer
 
 
 class AsyncVectorLayer(AsyncBase):
@@ -667,6 +665,8 @@ class AsyncVectorLayer(AsyncBase):
                             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.
@@ -704,6 +704,8 @@ class AsyncVectorLayer(AsyncBase):
         """
         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),
@@ -1032,14 +1034,10 @@ class AsyncVectorLayer(AsyncBase):
             factory_func=lambda api, item: AsyncVectorLayerView(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.
@@ -1049,9 +1047,9 @@ class AsyncVectorLayer(AsyncBase):
             >>> from geobox.aio.vectorlayer import AsyncVectorLayer
             >>> async with AsyncGeoboxClient() as client:
             >>>     layer = await AsyncVectorLayer.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}'
@@ -1356,27 +1354,3 @@ class AsyncVectorLayer(AsyncBase):
             feature=feature,
             display_name=display_name,
             description=description)
-    
-
-    def to_sync(self, sync_client: 'GeoboxClient') -> 'VectorLayer':
-        """
-        Switch to sync version of the vector layer instance to have access to the sync methods
-
-        Args:
-            sync_client (GeoboxClient): The sync version of the GeoboxClient instance for making requests.
-
-        Returns:
-            VectorLayer: the sync instance of the vector layer.
-
-        Example:
-            >>> from geobox import Geoboxclient
-            >>> from geobox.aio import AsyncGeoboxClient
-            >>> from geobox.aio.vectorlayer import AsyncVectorLayer
-            >>> client = GeoboxClient()
-            >>> async with AsyncGeoboxClient() as async_client:
-            >>>     layer = await AsyncVectorLayer.get_vector(async_client, uuid="12345678-1234-5678-1234-567812345678")
-            >>>     sync_layer = layer.to_sync(client)
-        """
-        from ..vectorlayer import VectorLayer
-
-        return VectorLayer(api=sync_client, uuid=self.uuid, layer_type=self.layer_type, data=self.data)

geobox/aio/version.py

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

geobox/aio/view.py

@@ -11,8 +11,6 @@ if TYPE_CHECKING:
     from .file import AsyncFile
     from .attachment import AsyncAttachment
     from ..enums import InputGeomType
-    from ..api import GeoboxClient
-    from ..view import VectorLayerView
 
 
 class AsyncVectorLayerView(AsyncVectorLayer):
@@ -701,14 +699,10 @@ class AsyncVectorLayerView(AsyncVectorLayer):
             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.
@@ -718,9 +712,9 @@ class AsyncVectorLayerView(AsyncVectorLayer):
             >>> from geobox.aio.view import AsyncVectorLayerView
             >>> async with AsyncGeoboxClient() as client:
             >>>     view = await AsyncVectorLayerView.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
     
 
     async def get_tile_json(self) -> Dict:
@@ -958,7 +952,7 @@ class AsyncVectorLayerView(AsyncVectorLayer):
         file: 'AsyncFile',
         feature: 'AsyncFeature' = None,
         display_name: str = None, 
-        description: str = None) -> 'Attachment':
+        description: str = None) -> 'AsyncAttachment':
         """
         [async] Create a new Attachment.
 
@@ -997,27 +991,3 @@ class AsyncVectorLayerView(AsyncVectorLayer):
             feature=feature,
             display_name=display_name,
             description=description)
-    
-
-    def to_sync(self, sync_client: 'GeoboxClient') -> 'VectorLayerView':
-        """
-        Switch to sync version of the view instance to have access to the sync methods
-
-        Args:
-            sync_client (GeoboxClient): The sync version of the GeoboxClient instance for making requests.
-
-        Returns:
-            VectorLayerView: the sync instance of the view.
-
-        Example:
-            >>> from geobox import Geoboxclient
-            >>> from geobox.aio import AsyncGeoboxClient
-            >>> from geobox.aio.view import AsyncVectorLayerView
-            >>> client = GeoboxClient()
-            >>> async with AsyncGeoboxClient() as async_client:
-            >>>     view = await AsyncVectorLayerView.get_view(async_client, uuid="12345678-1234-5678-1234-567812345678")
-            >>>     sync_view = view.to_sync(client)
-        """
-        from ..view import VectorLayerView
-
-        return VectorLayerView(api=sync_client, uuid=self.uuid, layer_type=self.layer_type, data=self.data)

geobox/aio/workflow.py

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