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

geobox/aio/file.py

@@ -7,27 +7,27 @@ import aiohttp
 import sys
 
 from .base import AsyncBase
-from .task import Task
-from .feature import Feature
+from .task import AsyncTask
+from .feature import AsyncFeature
 from ..enums import FileFormat, PublishFileType, InputGeomType, FileType
 from ..utils import clean_data, get_save_path, get_unique_filename
 from ..exception import ApiRequestError
 
 if TYPE_CHECKING:
     from . import AsyncGeoboxClient 
-    from .user import User
-    from ..api import GeoboxClient as SyncGeoboxClient
-    from ..file import File as SyncFile
+    from .user import AsyncUser
+    from ..api import GeoboxClient
+    from ..file import File
 
 
-class File(AsyncBase):
+class AsyncFile(AsyncBase):
 
     BASE_ENDPOINT: str = 'files/'
 
     def __init__(self, 
-                api: 'AsyncGeoboxClient', 
-                uuid: str, 
-                data: Optional[Dict] = {}):
+        api: 'AsyncGeoboxClient', 
+        uuid: str, 
+        data: Optional[Dict] = {}):
         """
         Constructs all the necessary attributes for the File object.
 
@@ -46,7 +46,7 @@ class File(AsyncBase):
         Returns:
             str: A string representation of the File object.
         """
-        return f"File(uuid={self.uuid}, file_name={self.name}, file_type={self.file_type.value})"
+        return f"AsyncFile(uuid={self.uuid}, file_name={self.name}, file_type={self.file_type.value})"
 
 
     @property
@@ -84,7 +84,7 @@ class File(AsyncBase):
 
 
     @classmethod
-    async def upload_file(cls, api: 'AsyncGeoboxClient', path: str, user_id: int = None, scan_archive: bool = True) -> 'File':
+    async def upload_file(cls, api: 'AsyncGeoboxClient', path: str, user_id: int = None, scan_archive: bool = True) -> 'AsyncFile':
         """
         [async] Upload a file to the GeoBox API.
 
@@ -95,7 +95,7 @@ class File(AsyncBase):
             scan_archive (bool, optional): Whether to scan the archive for layers. default: True
 
         Returns:
-            File: The uploaded file instance.
+            AsyncFile: The uploaded file instance.
 
         Raises:
             ValueError: If the file type is invalid.
@@ -103,9 +103,9 @@ class File(AsyncBase):
 
         Example:
             >>> from geobox.aio import AsyncGeoboxClient
-            >>> from geobox.aio.file import File
+            >>> from geobox.aio.file import AsyncFile
             >>> async with AsyncGeoboxClient() as client:
-            >>>     file = await File.upload_file(client, path='path/to/file.shp')
+            >>>     file = await AsyncFile.upload_file(client, path='path/to/file.shp')
             or  
             >>>     file = await client.upload_file(path='path/to/file.shp')
         """
@@ -125,7 +125,7 @@ class File(AsyncBase):
         
 
     @classmethod
-    async def get_files(cls, api:'AsyncGeoboxClient', **kwargs) -> Union[List['File'], int]:
+    async def get_files(cls, api:'AsyncGeoboxClient', **kwargs) -> Union[List['AsyncFile'], int]:
         """
         [async] Retrieves a list of files.
 
@@ -144,13 +144,13 @@ class File(AsyncBase):
             shared (bool): Whether to return shared files. default is False.
             
         Returns:
-            List[File] | int: A list of File objects or the total number of results.
+            List[AsyncFile] | int: A list of File objects or the total number of results.
 
         Example:
             >>> from geobox.aio import AsyncGeoboxClient
-            >>> from geobox.aio.file import File
+            >>> from geobox.aio.file import AsyncFile
             >>> async with AsyncGeoboxClient() as client:
-            >>>     files = await File.get_files(client, search_fields='name', search='GIS', order_by='name', skip=10, limit=10)
+            >>>     files = await AsyncFile.get_files(client, search_fields='name', search='GIS', order_by='name', skip=10, limit=10)
             or  
             >>>     files = await client.get_files(search_fields='name', search='GIS', order_by='name', skip=10, limit=10)
         """
@@ -170,7 +170,7 @@ class File(AsyncBase):
 
 
     @classmethod
-    async def get_file(cls, api: 'AsyncGeoboxClient', uuid: str, user_id: int = None) -> 'File':
+    async def get_file(cls, api: 'AsyncGeoboxClient', uuid: str, user_id: int = None) -> 'AsyncFile':
         """
         [async] Retrieves a file by its UUID.
 
@@ -180,16 +180,16 @@ class File(AsyncBase):
             user_id (int, optional): specific user. privileges required.
 
         Returns:
-            File: The retrieved file instance.
+            AsyncFile: The retrieved file instance.
 
         Raises:
             NotFoundError: If the file with the specified UUID is not found.
 
         Example:
             >>> from geobox.aio import AsyncGeoboxClient
-            >>> from geobox.aio.file import File
+            >>> from geobox.aio.file import AsyncFile
             >>> async with AsyncGeoboxClient() as client:
-            >>>     file = await File.get_file(client, uuid="12345678-1234-5678-1234-567812345678")
+            >>>     file = await AsyncFile.get_file(client, uuid="12345678-1234-5678-1234-567812345678")
             or  
             >>>     file = await client.get_file(uuid="12345678-1234-5678-1234-567812345678")
         """
@@ -197,11 +197,11 @@ class File(AsyncBase):
             'f': 'json',
             'user_id': user_id
         }
-        return await super()._get_detail(api, cls.BASE_ENDPOINT, f'{uuid}/info', params, factory_func=lambda api, item: File(api, item['uuid'], item))
+        return await super()._get_detail(api, cls.BASE_ENDPOINT, f'{uuid}/info', params, factory_func=lambda api, item: AsyncFile(api, item['uuid'], item))
 
 
     @classmethod
-    async def get_files_by_name(cls, api: 'AsyncGeoboxClient', name: str, user_id: int = None) -> List['File']:
+    async def get_files_by_name(cls, api: 'AsyncGeoboxClient', name: str, user_id: int = None) -> List['AsyncFile']:
         """
         [async] Get files by name
 
@@ -211,13 +211,13 @@ class File(AsyncBase):
             user_id (int, optional): specific user. privileges required.
 
         Returns:
-            List[File]: returns files that matches the given name
+            List[AsyncFile]: returns files that matches the given name
 
         Example:
             >>> from geobox.aio import AsyncGeoboxClient
-            >>> from geobox.aio.file import File
+            >>> from geobox.aio.file import AsyncFile
             >>> async with AsyncGeoboxClient() as client:
-            >>>     files = await File.get_files_by_name(client, name='test')
+            >>>     files = await AsyncFile.get_files_by_name(client, name='test')
             or  
             >>>     files = await client.get_files_by_name(name='test')
         """
@@ -253,14 +253,14 @@ class File(AsyncBase):
             return None
 
         return tqdm(unit="B", 
-                        total=int(self.size), 
-                        file=sys.stdout,
-                        dynamic_ncols=True,
-                        desc="Downloading",
-                        unit_scale=True,
-                        unit_divisor=1024, 
-                        ascii=True
-                )
+            total=int(self.size), 
+            file=sys.stdout,
+            dynamic_ncols=True,
+            desc="Downloading",
+            unit_scale=True,
+            unit_divisor=1024, 
+            ascii=True
+        )
 
 
     async def download(self, save_path: str = None, progress_bar: bool = True, file_name: str = None, overwrite: bool = False) -> str:
@@ -284,9 +284,9 @@ class File(AsyncBase):
 
         Example:
             >>> from geobox.aio import AsyncGeoboxClient
-            >>> from geobox.aio.file import File
+            >>> from geobox.aio.file import AsyncFile
             >>> async with AsyncGeoboxClient() as client:
-            >>>     file = await File.get_file(client, uuid="12345678-1234-5678-1234-567812345678")
+            >>>     file = await AsyncFile.get_file(client, uuid="12345678-1234-5678-1234-567812345678")
             >>>     await file.download(save_path='path/to/save/')
         """
         if not self.uuid:
@@ -331,26 +331,26 @@ class File(AsyncBase):
 
         Example:
             >>> from geobox.aio import AsyncGeoboxClient
-            >>> from geobox.aio.file import File
+            >>> from geobox.aio.file import AsyncFile
             >>> async with AsyncGeoboxClient() as client:
-            >>>     file = await File.get_file(client, uuid="12345678-1234-5678-1234-567812345678")
+            >>>     file = await AsyncFile.get_file(client, uuid="12345678-1234-5678-1234-567812345678")
             >>>     await file.delete()
         """
-        return await super().delete(self.endpoint)
+        return await super()._delete(self.endpoint)
 
 
     async def publish(self, 
-                    name: str, 
-                    publish_as: 'PublishFileType' = None, 
-                    input_geom_type: 'InputGeomType' = None, 
-                    input_layer: str = None, 
-                    input_dataset: str = None, 
-                    user_id: int = None, 
-                    input_srid: int = Feature.BASE_SRID, 
-                    file_encoding: str = "UTF-8", 
-                    replace_domain_codes_by_values: bool = False, 
-                    report_errors: bool = True, 
-                    as_terrain: bool = False) -> 'Task':
+        name: str, 
+        publish_as: 'PublishFileType' = None, 
+        input_geom_type: 'InputGeomType' = None, 
+        input_layer: str = None, 
+        input_dataset: str = None, 
+        user_id: int = None, 
+        input_srid: int = AsyncFeature.BASE_SRID, 
+        file_encoding: str = "UTF-8", 
+        replace_domain_codes_by_values: bool = False, 
+        report_errors: bool = True, 
+        as_terrain: bool = False) -> 'AsyncTask':
         """
         [async] Publishes a file as a layer.
 
@@ -376,9 +376,9 @@ class File(AsyncBase):
 
         Example:
             >>> from geobox.aio import AsyncGeoboxClient
-            >>> from geobox.aio.file import File
+            >>> from geobox.aio.file import AsyncFile
             >>> async with AsyncGeoboxClient() as client:
-            >>>     file = await File.get_file(client, uuid="12345678-1234-5678-1234-567812345678")
+            >>>     file = await AsyncFile.get_file(client, uuid="12345678-1234-5678-1234-567812345678")
             >>>     await file.publish(publish_as=PublishFileType.VECTOR, 
             ...                         layer_name='my_layer', 
             ...                         input_geom_type=InputGeomType.POINT, 
@@ -425,11 +425,11 @@ class File(AsyncBase):
         })
         endpoint = urljoin(self.endpoint, 'publish/')
         response = await self.api.post(endpoint, data, is_json=False)
-        task = await Task.get_task(self.api, response.get('task_id'))
+        task = await AsyncTask.get_task(self.api, response.get('task_id'))
         return task
 
 
-    async def share(self, users: List['User']) -> None:
+    async def share(self, users: List['AsyncUser']) -> None:
         """
         [async] Shares the file with specified users.
 
@@ -441,37 +441,37 @@ class File(AsyncBase):
 
         Example:
             >>> from geobox.aio import AsyncGeoboxClient
-            >>> from geobox.aio.file import File
+            >>> from geobox.aio.file import AsyncFile
             >>> async with AsyncGeoboxClient() as client:
-            >>>     file = await File.get_file(client, uuid="12345678-1234-5678-1234-567812345678")
+            >>>     file = await AsyncFile.get_file(client, uuid="12345678-1234-5678-1234-567812345678")
             >>>     users = await client.search_users(search='John')
             >>>     await file.share(users=users)
         """
         await super()._share(self.endpoint, users)
     
 
-    async def unshare(self, users: List['User']) -> None:
+    async def unshare(self, users: List['AsyncUser']) -> None:
         """
         [async] Unshares the file with specified users.
 
         Args:
-            users (List[User]): The list of users objects to unshare the file with.
+            users (List[AsyncUser]): The list of users objects to unshare the file with.
 
         Returns:
             None
 
         Example:
             >>> from geobox.aio import AsyncGeoboxClient
-            >>> from geobox.aio.file import File
+            >>> from geobox.aio.file import AsyncFile
             >>> async with AsyncGeoboxClient() as client:
-            >>>     file = await File.get_file(client, uuid="12345678-1234-5678-1234-567812345678")
+            >>>     file = await AsyncFile.get_file(client, uuid="12345678-1234-5678-1234-567812345678")
             >>>     await users = client.search_users(search='John')
             >>>     await file.unshare(users=users)
         """
         await super()._unshare(self.endpoint, users)
 
 
-    async def get_shared_users(self, search: str = None, skip: int = 0, limit: int = 10) -> List['User']:
+    async def get_shared_users(self, search: str = None, skip: int = 0, limit: int = 10) -> List['AsyncUser']:
         """
         [async] Retrieves the list of users the file is shared with.
 
@@ -481,13 +481,13 @@ class File(AsyncBase):
             limit (int, optional): The maximum number of users to retrieve.
 
         Returns:
-            List[User]: The list of shared users.
+            List[AsyncUser]: The list of shared users.
 
         Example:
             >>> from geobox.aio import AsyncGeoboxClient
-            >>> from geobox.aio.file import File
+            >>> from geobox.aio.file import AsyncFile
             >>> async with AsyncGeoboxClient() as client:
-            >>>     file = await File.get_file(client, uuid="12345678-1234-5678-1234-567812345678")
+            >>>     file = await AsyncFile.get_file(client, uuid="12345678-1234-5678-1234-567812345678")
             >>>     await file.get_shared_users(search='John', skip=0, limit=10)
         """
         params = {
@@ -498,25 +498,25 @@ class File(AsyncBase):
         return await super()._get_shared_users(self.endpoint, params)
 
 
-    def to_sync(self, sync_client: 'SyncGeoboxClient') -> 'SyncFile':
+    def to_sync(self, sync_client: 'GeoboxClient') -> 'File':
         """
         Switch to sync version of the file instance to have access to the sync methods
 
         Args:
-            sync_client (SyncGeoboxClient): The sync version of the GeoboxClient instance for making requests.
+            sync_client (GeoboxClient): The sync version of the GeoboxClient instance for making requests.
 
         Returns:
-            geobox.file.File: the async instance of the file.
+            File: the async instance of the file.
 
         Example:
             >>> from geobox import Geoboxclient
             >>> from geobox.aio import AsyncGeoboxClient
-            >>> from geobox.aio.file import File
+            >>> from geobox.aio.file import AsyncFile
             >>> client = GeoboxClient()
             >>> async with AsyncGeoboxClient() as async_client:
-            >>>     file = await File.get_file(async_client, uuid="12345678-1234-5678-1234-567812345678")
+            >>>     file = await AsyncFile.get_file(async_client, uuid="12345678-1234-5678-1234-567812345678")
             >>>     sync_file = file.to_sync(client)
         """
-        from ..file import File as SyncFile
+        from ..file import File
 
-        return SyncFile(api=sync_client, uuid=self.uuid, data=self.data)
+        return File(api=sync_client, uuid=self.uuid, data=self.data)