geobox 1.4.2__py3-none-any.whl → 2.0.1__py3-none-any.whl

geobox/aio/base.py

@@ -0,0 +1,262 @@
+from typing import Any, List, Dict, Callable, TYPE_CHECKING, Union
+from urllib.parse import urljoin, urlencode
+from datetime import datetime
+
+from ..utils import clean_data
+from ..base import Base as SyncBase
+
+if TYPE_CHECKING:
+    from .user import User
+    from .task import Task
+    from . import AsyncGeoboxClient
+
+
+class AsyncBase(SyncBase):
+    BASE_ENDPOINT = ''
+    
+    def __init__(self, api, **kwargs):
+        """
+        Initialize the Base class.
+
+        Args:
+            api (AsyncGeoboxClient): The AsyncGeoboxClient client
+            uuid (str, optional): The UUID of the resource
+            data (dict, optional): The data of the resource
+        """
+        super().__init__(api, **kwargs)
+
+
+    @classmethod
+    async def _get_list(cls, api: 'AsyncGeoboxClient', endpoint: str, params: dict = {}, 
+                factory_func: Callable = None, geojson: bool = False) -> Union[List['Base'], int]:
+        """Get a list of resources with optional filtering and pagination"""
+        query_string = urlencode(clean_data(params)) if params else ''
+        endpoint = urljoin(endpoint, f'?{query_string}')
+        response = await api.get(endpoint)
+
+        if params.get('return_count'):
+            return cls._get_count(response)
+        
+        if not response:
+            return []
+            
+        if geojson:
+            return cls._handle_geojson_response(api, response, factory_func)
+            
+        return [factory_func(api, item) for item in response]
+    
+
+    @classmethod
+    async def _get_list_by_ids(cls, api: 'AsyncGeoboxClient', endpoint: str, params: dict = None, factory_func: Callable = None) -> List['Base']:
+        """
+        Internal method to get a list of resources by their IDs.
+
+        Args:
+            api (AsyncGeoboxClient): The AsyncGeoboxClient client
+            endpoint (str): The endpoint of the resource
+            params (dict): Additional parameters for filtering and pagination
+            factory_func (Callable): A function to create the resource object
+
+        Returns:
+            List[Base]: The list of resource objects
+        """
+        params = clean_data(params)
+        query_string = urlencode(params)
+        endpoint = urljoin(endpoint, f'?{query_string}')
+        response = await api.get(endpoint)
+        return [factory_func(api, item) for item in response]
+
+
+    @classmethod
+    async def _get_detail(cls, api: 'AsyncGeoboxClient', endpoint: str, uuid: str, params: dict = {}, factory_func: Callable = None) -> 'Base':
+        """
+        Internal method to get a single resource by UUID.
+        
+        Args:
+            api (AsyncGeoboxClient): The AsyncGeoboxClient client
+            uuid (str): The UUID of the resource
+            params (dict): Additional parameters for filtering and pagination
+            factory_func (Callable): A function to create the resource object
+
+        Returns:
+            Base: The resource object
+        """
+        query_strings = urlencode(clean_data(params))
+        endpoint = urljoin(endpoint, f'{uuid}/?{query_strings}')
+        response = await api.get(endpoint)
+        return factory_func(api, response)
+    
+
+    @classmethod
+    async def _create(cls, api: 'AsyncGeoboxClient', endpoint: str, data: dict, factory_func: Callable = None) -> 'Base':
+        """
+        Internal method to create a resource.
+
+        Args:
+            api (AsyncGeoboxClient): The AsyncGeoboxClient client
+            data (dict): The data to create the resource with
+            factory_func (Callable): A function to create the resource object
+
+        Returns:
+            Base: The created resource object
+        """
+        data = clean_data(data)
+        response = await api.post(endpoint, data)
+        return factory_func(api, response)
+    
+
+    async def _update(self, endpoint: str, data: dict, clean: bool = True) -> Dict:
+        """
+        Update the resource.
+
+        Args:
+            data (dict): The data to update the resource with
+        """
+        if clean:
+            data = clean_data(data)
+
+        response = await self.api.put(endpoint, data)
+        self._update_properties(response)
+        return response
+    
+
+    async def delete(self, endpoint: str) -> None:
+        """
+        Delete the resource.
+        """
+        await self.api.delete(endpoint)
+        self.uuid = None
+        self.endpoint = None
+        
+
+    async def _share(self, endpoint: str, users: List['User']) -> None:
+        """
+        Internal method to share the resource with the given user IDs.
+
+        Args:
+            users (List[User]): The user objects to share the resource with
+        """
+        data = {"user_ids": [user.user_id for user in users]}
+        endpoint = urljoin(endpoint, f'share/')
+        await self.api.post(endpoint, data, is_json=False)
+
+
+    async def _unshare(self, endpoint: str, users: List['User']) -> None:
+        """
+        Internal method to unshare the resource with the given user IDs.
+
+        Args:
+            users (List[User]): The user objects to unshare the resource with
+        """
+        data = {"user_ids": [user.user_id for user in users]}
+        endpoint = urljoin(endpoint, f'unshare/')
+        await self.api.post(endpoint, data, is_json=False)
+
+
+    async def _get_shared_users(self, endpoint: str, params: dict = None) -> List['User']:
+        """
+        Internal method to get the users that the resource is shared with.
+
+        Args:
+            endpoint (str): resource endpoint
+            params (dict): Additional parameters for filtering and pagination
+
+        Returns:
+            List[User]: The users that the resource is shared with
+        """
+        from .user import User
+
+        params = clean_data(params)
+        query_strings = urlencode(params)
+        endpoint = urljoin(endpoint, f'shared-with-users/?{query_strings}')
+        response = await self.api.get(endpoint)
+        return [User(self.api, item['id'], item) for item in response]
+    
+
+    async def _get_settings(self, endpoint: str) -> Dict:
+        """
+        Internal method to get the settings of the resource.
+
+        Args:
+            endpoint (str): The endpoint of the resource
+        """
+        endpoint = urljoin(endpoint, f'settings/?f=json')
+        return await self.api.get(endpoint)
+    
+
+    async def _set_settings(self, endpoint: str, data: dict) -> None:
+        """
+        Internal method to set the settings of the resource.
+
+        Args:
+            endpoint (str): The endpoint of the resource
+            data (dict): The data to set the settings with
+        """
+        endpoint = urljoin(endpoint, f'settings/')
+        return await self.api.put(endpoint, data)
+
+
+    async def _get_task(self, response, error_message: str) -> List['Task']:
+        from .task import Task  # avoid circular dependency
+
+        if len(response) == 1 and isinstance(response, list) and response[0].get('task_id'):
+            result = [await self.api.get_task(response[0].get('task_id'))]
+        elif len(response) == 2 and isinstance(response, list) and (response[0].get('task_id') and response[1].get('task_id')):
+            result = [await self.api.get_task(item.get('task_id')) for item in response]
+        elif len(response) == 1 and isinstance(response, dict) and response.get('task_id'):
+            result = [await self.api.get_task(response.get('task_id'))]
+        else:
+            raise ValueError(error_message)
+
+        return result
+
+
+    async def _seed_cache(self, endpoint: str, data: dict) -> List['Task']:
+        """
+        Internal method to cache seed the resource.
+
+        Args:
+            endpoint (str): The endpoint of the resource
+            data (dict): The data to cache seed with
+        """
+        if data['workers'] not in [1, 2, 4, 8, 12, 16, 20, 24]:
+            raise ValueError("workers must be in [1, 2, 4, 8, 12, 16, 20, 24]")
+        
+        data = clean_data(data)
+        endpoint = urljoin(endpoint, f'cache/seed/')
+        response = await self.api.post(endpoint, data)
+        return await self._get_task(response, 'Failed to seed cache')
+
+    async def _clear_cache(self, endpoint: str) -> None:
+        """
+        Internal method to clear the cache of the resource.
+
+        Args:
+            endpoint (str): The endpoint of the resource
+        """
+        endpoint = urljoin(endpoint, f'cache/clear/')
+        await self.api.post(endpoint)
+
+
+    async def _cache_size(self, endpoint: str) -> int:
+        """
+        Internal method to get the size of the cache of the resource.
+
+        Args:
+            endpoint (str): The endpoint of the resource
+        """
+        endpoint = urljoin(endpoint, f'cache/size/')
+        return await self.api.post(endpoint)
+    
+
+    async def _update_cache(self, endpoint: str, data: Dict = {}) -> List['Task']:
+        """
+        Internal method to update the cache of the resource.
+
+        Args:
+            endpoint (str): The endpoint of the resource
+        """
+        data = clean_data(data)
+        endpoint = urljoin(endpoint, 'cache/update/')
+        response = await self.api.post(endpoint, data)
+        return await self._get_task(response, 'Failed to update cache')

geobox/aio/basemap.py

@@ -0,0 +1,196 @@
+from typing import List, Dict, Optional, TYPE_CHECKING
+from urllib.parse import urljoin, urlencode
+
+from .base import AsyncBase
+from ..exception import NotFoundError
+from ..utils import clean_data
+
+if TYPE_CHECKING:
+    from . import AsyncGeoboxClient
+    from ..api import GeoboxClient as SyncGeoboxClient
+    from ..basemap import Basemap as SyncBasemap
+
+
+class Basemap(AsyncBase):
+
+    BASE_ENDPOINT = 'basemaps/'
+
+    def __init__(self, 
+                 api: 'AsyncGeoboxClient', 
+                 data: Optional[Dict] = {}):
+        """
+        Initialize a basemap instance.
+
+        Args:
+            api (AsyncGeoboxClient): The AsyncGeoboxClient instance for making requests.
+            data (Dict): The data of the basemap.
+        """
+        super().__init__(api, data=data)
+        self.endpoint = f"{self.BASE_ENDPOINT}{self.data.get('name')}/"
+
+
+    @classmethod
+    async def get_basemaps(cls, api: 'AsyncGeoboxClient') -> List['Basemap']:
+        """
+        [async] Get a list of basemaps
+
+        Args:
+            api (AsyncGeoboxClient): The AsyncGeoboxClient instance for making requests.
+
+        Returns:
+            List[BaseMap]: list of basemaps.
+
+        Example:
+            >>> from geobox.aio import AsyncGeoboxClient
+            >>> from geobox.aio.basemap import Basemap
+            >>> async with AsyncGeoboxClient() as client:
+            >>>     basemaps = await Basemap.get_basemaps(client)
+            or  
+            >>>     basemaps = await client.get_basemaps()
+        """
+        response = await api.get(cls.BASE_ENDPOINT)
+        if not response:
+            return []
+
+        items = []
+        for item in response:
+            response[item]['name'] = item
+            items.append(response[item])
+
+        return [cls(api, item) for item in items]
+
+
+    @classmethod
+    async def get_basemap(cls, api: 'AsyncGeoboxClient', name: str) -> 'Basemap':
+        """
+        [async] Get a basemap object
+
+        Args:
+            api (AsyncGeoboxClient): The AsyncGeoboxClient instance for making requests.
+            name: the basemap name
+
+        Returns:
+            Basemap: the basemap object
+
+        Raises:
+            NotFoundError: if the base,ap with the specified name not found
+
+        Example:
+            >>> from geobox.aio import AsyncGeoboxClient
+            >>> from geobox.aio.basemap import Basemap
+            >>> async with AsyncGeoboxClient() as client:
+            >>>     basemap = await Basemap.get_basemap(client, name='test')
+            or  
+            >>>     basemap = await client.get_basemap(name='test')
+        """
+        response = await cls.get_basemaps(api)
+        basemap = [basemap for basemap in response if basemap.name == name]
+        if not basemap:
+            raise NotFoundError(f'Basemap with name "{name}" not found.')
+
+        return basemap[0]
+
+
+    @property
+    def thumbnail(self) -> str:
+        """
+        Get the thumbnail url of the basemap
+
+        Returns:
+            str: the thumbnail url
+        """
+        return super().thumbnail()
+    
+
+    @property
+    def wmts(self) -> str:
+        """
+        Get the wmts url of the basemap
+
+        Returns:
+            str: the wmts url
+        """
+        endpoint = urljoin(self.api.base_url, f'{self.endpoint}wmts/')
+
+        if not self.api.access_token and self.api.apikey:
+            endpoint = f"{endpoint}?apikey={self.api.apikey}"
+            
+        return endpoint
+    
+
+    @property
+    async def server_url(self) -> str:
+        """
+        [async] Get the server url of the basemap
+
+        Returns:
+            str: the server url
+        """
+        endpoint = f'{self.api.base_url}{self.BASE_ENDPOINT}server_url'
+        return await self.api.get(endpoint)
+    
+
+    @property
+    async def proxy_url(self) -> str:
+        """
+        [async] Get the proxy url of the basemap
+
+        Returns:
+            str: the proxy url
+        """
+        endpoint = f'{self.api.base_url}{self.BASE_ENDPOINT}proxy_url'
+        return await self.api.get(endpoint)
+    
+
+    @classmethod
+    async def proxy_basemap(cls, api: 'response', url: str) -> None:
+        """
+        [async] Proxy the basemap
+
+        Args:
+            api (GeoboxClient): The GeoboxClient instance for making requests.
+            url (str): the proxy server url.
+
+        Returns:
+            None
+
+        Example:
+            >>> from geobox.aio import AsyncGeoboxClient
+            >>> from geobox.aio.basemap import Basemap
+            >>> async with AsyncGeoboxClient() as client:
+            >>>     await Basemap.proxy_basemap(client, url='proxy_server_url')
+            or  
+            >>>     await client.proxy_basemap(url='proxy_server_url')
+        """
+        param = clean_data({
+            'url': url
+        })
+        query_string = urlencode(param)
+        endpoint = urljoin(cls.BASE_ENDPOINT, f"?{query_string}")
+        await api.get(endpoint)
+
+
+    def to_sync(self, sync_client: 'SyncGeoboxClient') -> 'SyncBasemap':
+        """
+        Switch to sync version of the basemap instance to have access to the sync methods
+
+        Args:
+            sync_client (SyncGeoboxClient): The sync version of the GeoboxClient instance for making requests.
+
+        Returns:
+            geobox.basemap.Basemap: the sync instance of the basemap.
+
+        Example:
+            >>> from geobox import Geoboxclient
+            >>> from geobox.aio import AsyncGeoboxClient
+            >>> from geobox.aio.basemap import Basemap
+            >>> client = GeoboxClient()
+            >>> async with AsyncGeoboxClient() as async_client:
+            >>>     basemap = await Basemap.get_basemap(async_client, name='test')
+            or  
+            >>>     basemap = await async_client.get_basemap(name='test')
+            >>>     sync_basemap = basemap.to_sync(client)
+        """
+        from ..basemap import Basemap as SyncBasemap
+
+        return SyncBasemap(api=sync_client, data=self.data)