add ramdisk, load AI model to ramdisk and start recognition from it

rewrite zmq to DEALER and ROUTER
add GET_USER command to get CurrentUser from Python
all auth is on the python side
inference run and validate annotations on python

Azaion.AI/api_client.pyx

@@ -1,13 +1,14 @@
-import io
 import json
 import os
 from http import HTTPStatus
-
+from uuid import UUID
+import jwt
 import requests
 cimport constants
 from hardware_service cimport HardwareService, HardwareInfo
 from security cimport Security
 from io import BytesIO
+from user cimport User, RoleEnum
 
 cdef class ApiClient:
     """Handles API authentication and downloading of the AI model."""
@@ -15,9 +16,11 @@ cdef class ApiClient:
         self.email = email
         self.password = password
         self.folder = folder
+        self.user = None
+
         if os.path.exists(<str>constants.TOKEN_FILE):
             with open(<str>constants.TOKEN_FILE, "r") as file:
-                self.token = file.read().strip()
+                self.set_token(<str>file.read().strip())
         else:
             self.token = None
 
@@ -25,21 +28,52 @@ cdef class ApiClient:
         cdef str key = f'{self.email}-{self.password}-{hardware_hash}-#%@AzaionKey@%#---'
         return Security.calc_hash(key)
 
-    cdef login(self, str email, str password):
-        response = requests.post(f"{constants.API_URL}/login", json={"email": email, "password": password})
+    cdef login(self):
+        response = requests.post(f"{constants.API_URL}/login",
+                                 json={"email": self.email, "password": self.password})
         response.raise_for_status()
-        self.token = response.json()["token"]
-
+        token = response.json()["token"]
+        self.set_token(token)
         with open(<str>constants.TOKEN_FILE, 'w') as file:
-            file.write(self.token)
+            file.write(token)
 
+    cdef set_token(self, str token):
+        self.token = token
+        claims = jwt.decode(token, options={"verify_signature": False})
+
+        try:
+            id = str(UUID(claims.get("nameid", "")))
+        except ValueError:
+            raise ValueError("Invalid GUID format in claims")
+
+        email = claims.get("unique_name", "")
+
+        role_str = claims.get("role", "")
+        if role_str == "ApiAdmin":
+            role = RoleEnum.ApiAdmin
+        elif role_str == "Admin":
+            role = RoleEnum.Admin
+        elif role_str == "ResourceUploader":
+            role = RoleEnum.ResourceUploader
+        elif role_str == "Validator":
+            role = RoleEnum.Validator
+        elif role_str == "Operator":
+            role = RoleEnum.Operator
+        else:
+            role = RoleEnum.NONE
+        self.user = User(id, email, role)
+
+    cdef get_user(self):
+        if self.user is None:
+            self.login()
+        return self.user
 
     cdef load_bytes(self, str filename):
         hardware_service = HardwareService()
         cdef HardwareInfo hardware = hardware_service.get_hardware_info()
 
         if self.token is None:
-            self.login(self.email, self.password)
+            self.login()
 
         url = f"{constants.API_URL}/resources/get/{self.folder}"
         headers = {
@@ -56,7 +90,7 @@ cdef class ApiClient:
         response = requests.post(url, data=payload, headers=headers, stream=True)
 
         if response.status_code == HTTPStatus.UNAUTHORIZED or response.status_code == HTTPStatus.FORBIDDEN:
-            self.login(self.email, self.password)
+            self.login()
             headers = {
                 "Authorization": f"Bearer {self.token}",
                 "Content-Type": "application/json"
@@ -69,7 +103,9 @@ cdef class ApiClient:
         key = self.get_encryption_key(hardware.hash)
 
         stream = BytesIO(response.raw.read())
-        return Security.decrypt_to(stream, key)
+        data = Security.decrypt_to(stream, key)
+        print(f'loaded file: {filename}, {len(data)} bytes')
+        return data
 
     cdef load_ai_model(self):
         return self.load_bytes(constants.AI_MODEL_FILE)