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

geobox/aio/usage.py

@@ -1,26 +1,26 @@
-from urllib.parse import urlencode, urljoin
-from typing import Optional, Dict, List, Union, TYPE_CHECKING
+from urllib.parse import urlencode
+from typing import Dict, List, Union, TYPE_CHECKING
 from datetime import datetime
 
 from .base import AsyncBase
-from .user import User
-from .apikey import ApiKey
+from .user import AsyncUser
+from .apikey import AsyncApiKey
 from ..utils import clean_data
 from ..enums import UsageScale, UsageParam
 
 if TYPE_CHECKING:
     from . import AsyncGeoboxClient
-    from ..api import GeoboxClient as SyncGeoboxClient
-    from ..usage import Usage as SyncUsage
+    from ..api import GeoboxClient
+    from ..usage import Usage
 
 
-class Usage(AsyncBase):
+class AsyncUsage(AsyncBase):
 
     BASE_ENDPOINT = 'usage/'
 
     def __init__(self,
-                api: 'AsyncGeoboxClient',
-                user: 'User'):
+        api: 'AsyncGeoboxClient',
+        user: 'AsyncUser'):
         """
         Constructs the necessary attributes for the Usage object.
 
@@ -39,25 +39,25 @@ class Usage(AsyncBase):
         Returns:
             str: A string representation of the Usage object.
         """
-        return f"Usage(user={self.user})"
+        return f"AsyncUsage(user={self.user})"
 
 
     @classmethod
     async def get_api_usage(cls, 
-                        api: 'AsyncGeoboxClient', 
-                        resource: Union['User', 'ApiKey'], 
-                        scale: 'UsageScale',
-                        param: 'UsageParam',
-                        from_date: 'datetime' = None,
-                        to_date: 'datetime' = None,
-                        days_before_now: int = None,
-                        limit: int = None) -> List:
+        api: 'AsyncGeoboxClient', 
+        resource: Union['AsyncUser', 'AsyncApiKey'], 
+        scale: 'UsageScale',
+        param: 'UsageParam',
+        from_date: 'datetime' = None,
+        to_date: 'datetime' = None,
+        days_before_now: int = None,
+        limit: int = None) -> List:
         """
         [async] Get the api usage of a user
 
         Args:
             api (AsyncGeoboxClient): The AsyncGeoboxClient instance for making requests.
-            resource (User | ApiKey): User or ApiKey object.
+            resource (AsyncUser | AsyncApiKey): User or ApiKey object.
             scale (UsageScale): the scale of the report.
             param (UsageParam): traffic or calls.
             from_date (datetime, optional): datetime object in this format: "%Y-%m-%dT%H:%M:%S". 
@@ -74,10 +74,10 @@ class Usage(AsyncBase):
 
         Example:
             >>> from geobox.aio import AsyncGeoboxClient
-            >>> from geobox.aio.usage import Usage
+            >>> from geobox.aio.usage import AsyncUsage
             >>> async with AsyncGeoboxClient() as client:
             >>>     user = await client.get_user() # gets current user
-            >>>     usage = await Usage.get_api_usage(client, 
+            >>>     usage = await AsyncUsage.get_api_usage(client, 
             ...                                         resource=user, 
             ...                                         scale=UsageScale.Day, 
             ...                                         param=UsageParam.Calls, 
@@ -92,21 +92,22 @@ class Usage(AsyncBase):
             raise ValueError("one of days_before_now or from_date/to_date parameters must have value")
 
         params = {}
-        if isinstance(resource, User):
+        if isinstance(resource, AsyncUser):
             params['eid'] = resource.user_id
-        elif isinstance(resource, ApiKey):
+        elif isinstance(resource, AsyncApiKey):
             params['eid'] = resource.key
         else:
-            raise ValueError("resource must be a 'user' or 'apikey' object")
-
-        params = clean_data({**params,
-                    'scale': scale.value if scale else None,
-                    'param': param.value if param else None,
-                    'from_date': from_date.strftime("%Y-%m-%dT%H:%M:%S.%f") if from_date else None,
-                    'to_date': to_date.strftime("%Y-%m-%dT%H:%M:%S.%f") if to_date else None,
-                    'days_before_now': days_before_now,
-                    'limit': limit
-                    })
+            raise ValueError("resource must be a 'AsyncUser' or 'AsyncApikey' object")
+
+        params = clean_data({
+            **params,
+            'scale': scale.value if scale else None,
+            'param': param.value if param else None,
+            'from_date': from_date.strftime("%Y-%m-%dT%H:%M:%S.%f") if from_date else None,
+            'to_date': to_date.strftime("%Y-%m-%dT%H:%M:%S.%f") if to_date else None,
+            'days_before_now': days_before_now,
+            'limit': limit
+        })
         query_strings = urlencode(params)
         endpoint = f"{cls.BASE_ENDPOINT}api?{query_strings}"
 
@@ -115,11 +116,11 @@ class Usage(AsyncBase):
 
     @classmethod
     async def get_process_usage(cls, 
-                            api: 'AsyncGeoboxClient',
-                            user_id: int = None, 
-                            from_date: datetime = None, 
-                            to_date: datetime = None, 
-                            days_before_now: int = None) -> float:
+        api: 'AsyncGeoboxClient',
+        user_id: int = None, 
+        from_date: datetime = None, 
+        to_date: datetime = None, 
+        days_before_now: int = None) -> float:
         """
         [async] Get process usage of a user in seconds
 
@@ -138,9 +139,9 @@ class Usage(AsyncBase):
 
         Example:
             >>> from geobox.aio import AsyncGeoboxClient
-            >>> from geobox.aio.usage import Usage
+            >>> from geobox.aio.usage import AsyncUsage
             >>> async with AsyncGeoboxClient() as client:
-            >>>     process_usage = await Usage.get_process_usage(client, days_before_now=5)
+            >>>     process_usage = await AsyncUsage.get_process_usage(client, days_before_now=5)
             or  
             >>>     process_usage = await client.get_process_usage(days_before_now=5)
         """
@@ -172,9 +173,9 @@ class Usage(AsyncBase):
 
         Returns:
             >>> from geobox.aio import AsyncGeoboxClient
-            >>> from geobox.aio.usage import Usage
+            >>> from geobox.aio.usage import AsyncUsage
             >>> async with AsyncGeoboxClient() as client:
-            >>>     usage_summary = await Usage.get_usage_summary(client)
+            >>>     usage_summary = await AsyncUsage.get_usage_summary(client)
             or  
             >>>     usage_summary = await client.get_usage_summary()
         """
@@ -200,9 +201,9 @@ class Usage(AsyncBase):
 
         Example:
             >>> from geobox.aio import AsyncGeoboxClient
-            >>> from geobox.aio.usage import Usage
+            >>> from geobox.aio.usage import AsyncUsage
             >>> async with AsyncGeoboxClient() as client:
-            >>>     await Usage.update_usage(client)
+            >>>     await AsyncUsage.update_usage(client)
             or  
             >>>     await client.update_usage()
         """
@@ -213,31 +214,31 @@ class Usage(AsyncBase):
         return await api.post(endpoint, payload=data)
 
 
-    def to_sync(self, sync_client: 'SyncGeoboxClient') -> 'SyncUsage':
+    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 (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.usage.Usage: the sync instance of the usage.
+            Usage: the sync instance of the usage.
 
         Example:
             >>> from geobox import Geoboxclient
             >>> from geobox.aio import AsyncGeoboxClient
-            >>> from geobox.aio.usage import Usage
+            >>> from geobox.aio.usage import AsyncUsage
             >>> client = GeoboxClient()
             >>> async with AsyncGeoboxClient() as async_client:
             >>>     user = await async_client.get_user()
-            >>>     usage = await Usage.get_api_usage(async_client, 
+            >>>     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 as SyncUsage
+        from ..usage import Usage
 
         user = self.user.to_sync(sync_client)
-        return SyncUsage(api=sync_client, user=user)
+        return Usage(api=sync_client, user=user)