read cdn yaml config from api

automate tensorrt model conversion in case of no existing one for user's gpu

Azaion.Inference/api_client.pyx

@@ -1,12 +1,15 @@
 import json
 from http import HTTPStatus
+from os import path
 from uuid import UUID
 import jwt
 import requests
 cimport constants
+import yaml
+
+from cdn_manager cimport CDNManager, CDNCredentials
 from hardware_service cimport HardwareService, HardwareInfo
 from security cimport Security
-from io import BytesIO
 from user cimport User, RoleEnum
 
 cdef class ApiClient:
@@ -15,9 +18,19 @@ cdef class ApiClient:
         self.credentials = None
         self.user = None
         self.token = None
+        self.cdn_manager = None
 
     cdef set_credentials(self, Credentials credentials):
         self.credentials = credentials
+        yaml_bytes = self.load_bytes(constants.CDN_CONFIG, <str>'')
+        yaml_config = yaml.safe_load(yaml_bytes)
+        creds = CDNCredentials(yaml_config["host"],
+                               yaml_config["downloader_access_key"],
+                               yaml_config["downloader_access_secret"],
+                               yaml_config["uploader_access_key"],
+                               yaml_config["uploader_access_secret"])
+
+        self.cdn_manager = CDNManager(creds)
 
     cdef login(self):
         response = requests.post(f"{constants.API_URL}/login",
@@ -57,13 +70,12 @@ cdef class ApiClient:
             self.login()
         return self.user
 
-    cdef upload_file(self, str filename, str folder=None):
-        folder = folder or self.credentials.folder
+    cdef upload_file(self, str filename,  bytes resource, str folder):
         if self.token is None:
             self.login()
         url = f"{constants.API_URL}/resources/{folder}"
         headers = { "Authorization": f"Bearer {self.token}" }
-        files = dict(data=open(<str>filename, 'rb'))
+        files = {'data': (filename, resource)}
         try:
             r = requests.post(url, headers=headers, files=files, allow_redirects=True)
             r.raise_for_status()
@@ -71,9 +83,7 @@ cdef class ApiClient:
         except Exception as e:
             print(f"Upload fail: {e}")
 
-    cdef load_bytes(self, str filename, str folder=None):
-        folder = folder or self.credentials.folder
-
+    cdef load_bytes(self, str filename, str folder):
         hardware_service = HardwareService()
         cdef HardwareInfo hardware = hardware_service.get_hardware_info()
 
@@ -111,22 +121,30 @@ cdef class ApiClient:
         constants.log(<str>f'Downloaded file: {filename}, {len(data)} bytes')
         return data
 
-    cdef load_ai_model(self, bint is_tensor=False):
-        if is_tensor:
-            big_file = <str> constants.AI_TENSOR_MODEL_FILE_BIG
-            small_file = <str> constants.AI_TENSOR_MODEL_FILE_SMALL
-        else:
-            big_file = <str>constants.AI_ONNX_MODEL_FILE_BIG
-            small_file = <str> constants.AI_ONNX_MODEL_FILE_SMALL
+    cdef load_big_small_resource(self, str resource_name, str folder, str key):
+        cdef str big_part = path.join(<str>folder, f'{resource_name}.big')
+        cdef str small_part = f'{resource_name}.small'
 
-        with open(big_file, 'rb') as binary_file:
+        with open(<str>big_part, 'rb') as binary_file:
             encrypted_bytes_big = binary_file.read()
-        print('read encrypted big file')
-        print(f'small file: {small_file}')
-        encrypted_bytes_small = self.load_bytes(small_file)
-        print('read encrypted small file')
-        encrypted_model_bytes = encrypted_bytes_small + encrypted_bytes_big
-        key = Security.get_model_encryption_key()
 
-        model_bytes = Security.decrypt_to(encrypted_model_bytes, key)
-        return model_bytes
+        encrypted_bytes_small = self.load_bytes(small_part, folder)
+
+        encrypted_bytes = encrypted_bytes_small + encrypted_bytes_big
+        result = Security.decrypt_to(encrypted_bytes, key)
+        return result
+
+    cdef upload_big_small_resource(self, bytes resource, str resource_name, str folder, str key):
+        cdef str big_part_name = f'{resource_name}.big'
+        cdef str small_part_name = f'{resource_name}.small'
+
+        resource_encrypted = Security.encrypt_to(<bytes>resource, key)
+        part_small_size = min(constants.SMALL_SIZE_KB * 1024, int(0.3 * len(resource_encrypted)))
+        part_small = resource_encrypted[:part_small_size]  # slice bytes for part1
+
+        part_big = resource_encrypted[part_small_size:]
+
+        self.cdn_manager.upload(<str>constants.MODELS_FOLDER, <str>big_part_name, part_big)
+        with open(path.join(<str>folder, <str>big_part_name), 'wb') as f:
+            f.write(part_big)
+        self.upload_file(small_part_name, part_small, constants.MODELS_FOLDER)