ciocore 8.0.1__py2.py3-none-any.whl → 8.1.0b3__py2.py3-none-any.whl

ciocore/VERSION

@@ -1 +1 @@
-8.0.1
+8.1.0-beta.3

ciocore/api_client.py

@@ -3,18 +3,21 @@ The api_client module is used to make requests to the Conductor API.
 """
 
 import base64
+import collections
+import datetime
+import hashlib
 import importlib
 import json
 import jwt
 import logging
 import os
 import platform
+import datetime
 import requests
 import socket
 import time
 import sys
 import platform
-import hashlib
 
 from urllib import parse
 
@@ -486,6 +489,30 @@ def account_name_from_jwt(token):
     return None
 
 
+def get_account_data():
+    """
+    Get the authenticated account's data.
+    
+    Returns:
+        dict: The account data.
+    """
+    token = read_conductor_credentials(True)
+    if not token:
+        return None
+    
+    payload = jwt.decode(token, verify=False)
+    return {
+        "email": payload.get("email"),
+        "domain": ".".join(payload.get("aud").split(".")[1:]),
+        "account_id" : payload.get("account"),
+        "user_id" : payload.get("id"),
+        "role": payload.get("role"),
+        "issued": datetime.datetime.fromtimestamp(payload.get("iat")),
+        "expiry": datetime.datetime.fromtimestamp(payload.get("exp")),
+        "token": token,
+    }
+    
+
 def request_instance_types(as_dict=False):
     """
     Get the list of available instances types.
@@ -786,3 +813,223 @@ def kill_tasks(job_id, *task_ids):
         raise Exception(msg)
     
     return json.loads(response)
+
+def _get_compute_usage(start_time, end_time):
+    """
+    Query the account usage to get the raw compute data. Private method.
+    
+    Compute includes licenses, instances and Conductor cost. Everything involved
+    with running a job.
+    
+    Please use the public method api_client.get_compute_usage() instead.
+    
+    Args:
+        start_time (datetime.datetime): The first day to include in the report. Only the date is considered and it's assumed to be in UTC.
+        end_time (datetime.datetime): The last day to include in the report. Only the date is considered and it's assumed to be in UTC.
+        
+    Returns:
+        list: A list of billing entries
+        
+    Examples:
+        >>> from ciocore import api_client
+        >>> api_client._get_compute_usage(start_time, end_time)
+            [
+                {
+                    "cores": 0.5, 
+                    "instance_cost": 0.019999999552965164, 
+                    "license_cost": 0.019999999552965164, 
+                    "minutes": 6.9700000286102295, 
+                    "self_link": 0, 
+                    "start_time": "Tue, 09 Jan 2024 18:00:00 GMT"
+                }, 
+                {
+                    "cores": 0.4, 
+                    "instance_cost": 0.019999999552965164, 
+                    "license_cost": 0.019999999552965164, 
+                    "minutes": 6.960000038146973, 
+                    "self_link": 1, 
+                    "start_time": "Tue, 09 Jan 2024 19:00:00 GMT"
+                }] 
+    """
+
+    api = ApiClient()
+
+    payload = {
+        "filter": json.dumps(
+            [{"field": "start_time", "op": ">=", "value": start_time.date().isoformat()},
+             {"field": "start_time", "op": "<", "value": end_time.date().isoformat()}]),
+        "group_by": json.dumps(["start_time"]),
+        "order_by": "start_time"
+    }
+
+    response, response_code = api.make_request(
+        uri_path="billing/get_usage", 
+        verb="GET",
+        raise_on_error=False,
+        use_api_key=True,
+        params=payload
+    )
+
+    if response_code not in [200]:
+        msg = f"Failed to query compute usage"
+        msg += "\nError %s ...\n%s" % (response_code, response)
+        raise Exception(msg)
+
+    return json.loads(response)['data']
+
+def _get_storage_usage(start_time, end_time):
+    """
+    Query the account usage to get the raw storage data. Private method.
+    
+    Please use the public method api_client.get_storage_usage() instead.
+    
+    Args:
+        start_time (datetime.datetime): The first day to include in the report. Only the date is considered and it's assumed to be in UTC.
+        end_time (datetime.datetime): The last day to include in the report. Only the date is considered and it's assumed to be in UTC.
+        
+    Returns:
+        dict: A dict of billing details related to storage
+        
+    Examples:
+        >>> from ciocore import api_client
+        >>> api_client._get_storage_usage(start_time, end_time)
+           {
+                "cost": "28.96", 
+                "cost_per_day": [
+                    4.022,
+                    4.502, 
+                    4.502, 
+                    5.102, 
+                    5.102, 
+                    5.732
+                ], 
+                "currency": "USD", 
+                "daily_price": "0.006", 
+                "end_date": "2024-01-07", 
+                "gibs_per_day": [
+                    679.714,
+                    750.34, 
+                    750.34, 
+                    850.36, 
+                    850.35, 
+                    955.32
+                ], 
+                "gibs_used": "806.07", 
+                "monthly_price": "0.18", 
+                "start_date": "2024-01-01", 
+                "storage_unit": "GiB"
+                }
+            ]
+            } 
+    """
+
+    api = ApiClient()
+    
+    # Add one day to the end time as the query is exclusive of the last day but
+    # we want consistency with _get_compute_usage()    
+    payload = {
+        "start": start_time.date().isoformat(),
+        "end": (end_time.date() + datetime.timedelta(days=1)).isoformat()
+    }
+
+    response, response_code = api.make_request(
+        uri_path="billing/get_storage_usage", 
+        verb="GET",
+        raise_on_error=False,
+        use_api_key=True,
+        params=payload
+    )
+
+    if response_code not in [200]:
+        msg = f"Failed to query storage usage"
+        msg += "\nError %s ...\n%s" % (response_code, response)
+        raise Exception(msg)
+
+    return json.loads(response)['data'][0]
+
+def get_compute_usage(start_time, end_time):
+    '''
+    Query the compute usage for an account.
+    
+    Compute includes licenses, instances and Conductor cost. Everything involved
+    with running a job.    
+    
+    Args:
+        start_time (datetime.datetime): The first day to include in the report. Only the date is considered and it's assumed to be in UTC.
+        end_time (datetime.datetime): The last day to include in the report. Only the date is considered and it's assumed to be in UTC.
+        
+    Returns:
+        dict: Each key is a date (UTC). The value is a dict with values for:
+                - cost: The total accumulated compute cost for the day
+                - corehours: The total accumulated core hours for the day
+                - walltime: The number of minutes that instances (regardless of type) were running
+        
+    Examples:
+        >>> from ciocore import api_client
+        >>> api_client.get_compute_usage(start_time, end_time)
+        {  '2024-01-09': {  'cost': 0.08,
+                            'corehours': 0.9, 
+                            'walltime': 13.93},
+            '2024-01-16': { 'cost': 0.12,
+                            'corehours': 0.9613, 
+                            'walltime': 7.21}}
+    '''
+    date_format = "%a, %d %b %Y %H:%M:%S %Z"
+    data = _get_compute_usage(start_time, end_time)
+
+    # Create a nested default dictionary with initial float values of 0.0
+    results =  collections.defaultdict(lambda: collections.defaultdict(float))
+
+    for entry in data:
+        entry_start_date = datetime.datetime.strptime(entry['start_time'], date_format).date().isoformat()
+
+        results[entry_start_date]['walltime'] += entry['minutes']
+        results[entry_start_date]['corehours'] += entry['cores']
+        results[entry_start_date]['cost'] += entry['license_cost'] + entry['instance_cost']
+
+    # Round the data to avoid FP errors
+    results[entry_start_date]['walltime'] = round(results[entry_start_date]['walltime'], 4)
+    results[entry_start_date]['corehours'] = round(results[entry_start_date]['corehours'], 4)
+    results[entry_start_date]['cost'] = round(results[entry_start_date]['cost'], 4)
+    
+    return results
+
+def get_storage_usage(start_time, end_time):
+    '''
+    Query the storage usage for an account.
+    
+    Storage is calculated twice a day (UTC) and the average is used.
+    
+    Args:
+        start_time (datetime.datetime): The first day to include in the report. Only the date is considered and it's assumed to be in UTC.
+        end_time (datetime.datetime): The last day to include in the report. Only the date is considered and it's assumed to be in UTC.
+        
+    Returns:
+        dict: Each key is a date (UTC). The value is a dict with values for:
+                - cost: The cost of accumulated storage for that one day
+                - GiB: The total amount of storage used on that day
+        
+    Examples:
+        >>> from ciocore import api_client
+        >>> api_client.get_storage_usage(start_time, end_time)
+        { '2024-01-01': {'cost': 4.022, 'GiB': 679.714},
+          '2024-01-02': {'cost': 4.502, 'GiB': 750.34},
+          '2024-01-03': {'cost': 4.502, 'GiB': 750.34}}
+    '''
+    one_day = datetime.timedelta(days=1)
+    
+    data = _get_storage_usage(start_time, end_time)
+
+    results =  {}
+
+    entry_date = datetime.date.fromisoformat(data['start_date'])
+
+    for cnt, entry in enumerate(data["cost_per_day"]):
+
+        entry_start_date = entry_date.isoformat()
+        results[entry_start_date] = {'cost': float(entry), 'GiB': float(data['gibs_per_day'][cnt])}
+        entry_date += one_day
+
+    return results
+
+

ciocore/data.py

@@ -53,7 +53,7 @@ def init(*products, **kwargs):
 
 def data(force=False):
     """
-    Provide projects, instance types, and software package data.
+    Provide projects, instance types, software package, and account data.
 
     Keyword Args:
         force: (bool) If `True`, then force the system to fetch fresh data -- Defaults to `False`.
@@ -62,10 +62,10 @@ def data(force=False):
         ValueError:  Module was not initialized with [init()](/data/#ciocore.data.init).
 
     Returns:
-        dict: Keys are `projects`, `instance_types`, `software`.
+        dict: Keys are `projects`, `instance_types`, `software`, `account`.
 
     When you access the data, if it has already been fetched, it will be returned. Otherwise,
-    requests will be made to fetch the data. You may need to authenticate in order to access the
+    requests will be made to fetch fresh data. You may need to authenticate in order to access the
     data.
 
     The set of instance types and software can be pruned to match the available platforms
@@ -84,7 +84,8 @@ def data(force=False):
 
     * **software** is a PackageTree object containing either all
     the software available at Conductor, or a subset based on specified products.
-
+    
+    * **account** is a dictionary containing account information gained from the JWT token.
 
     Examples:
         >>> from ciocore import data as coredata
@@ -98,6 +99,10 @@ def data(force=False):
 
         >>> coredata.data()["instance_types"]
         <ciocore.hardware_set.HardwareSet object at 0x0000028941CD9DC0>
+        
+        >>> coredata.data()["account"]["account_id"]
+        123456789012
+        
     """
 
     global __data__
@@ -129,6 +134,9 @@ def data(force=False):
         except Exception:
             pass   
         __data__["extra_environment"] = extra_env_vars
+        
+        __data__["account"] = api_client.get_account_data()
+        
 
         # PLATFORMS
         it_platforms = set([it["operating_system"] for it in instance_types])