sumit-sdk 1.2.4__py3-none-any.whl

sumit_sdk/api.py

@@ -0,0 +1,41 @@
+import os
+from sumit_sdk.api_helper import APIHelper
+import requests
+
+class APIClient(APIHelper):
+
+    def _get_data(self, endpoint: str, json_data: dict={}):
+        """
+        Makes a GET request to the given API endpoint.
+
+        Args:
+        - endpoint (str): The API endpoint to make the request to.
+        - json_data (dict, optional): The JSON data to send in the request. Defaults to None.
+
+        Returns:
+        - dict: The response from the API.
+        """            
+        headers = {"Authorization": f"Bearer {self.token}"}
+        response = requests.get(f"{self.api_url}/{endpoint}", json=json_data, headers=headers)
+        return response.json()
+    
+    def _post_data(self, endpoint: str, json_data: dict={}):
+        """
+        Makes a POST request to the given API endpoint.
+
+        Args:
+        - endpoint (str): The API endpoint to make the request to.
+        - json_data (dict, optional): The JSON data to send in the request. Defaults to None.
+
+        Returns:
+        - dict: The response from the API.
+        """        
+        headers = {"Authorization": f"Bearer {self.token}"}
+        response = requests.post(f"{self.api_url}/{endpoint}", json=json_data, headers=headers)
+        return response.json()
+    
+class BaseWrapper:
+    def __init__(self, api_instance) -> None:
+        if not isinstance(api_instance, APIClient):
+            raise TypeError("Expected api_instance to be an instance of APIClient")
+        self.api = api_instance

sumit_sdk/api_helper.py

@@ -0,0 +1,109 @@
+import json
+import requests
+import os
+from retry import retry
+
+API_URL = {
+    "prod": "https://api.sumit-labs.com",
+    "tenants": "https://api.{tenant}.sumit-labs.com",
+}
+
+class APIEPS:
+    login = 'login'
+    realtime_update = 'realtime/set_status'
+
+class APIHelper:
+    def __init__(self, cred_path: str, env="prod", onprem=False, verify_ssl=None) -> None:
+        """
+        Initializes the APIHelper.
+
+        Args:
+        - cred_path (str): The credential json path
+        - env (str): api environment. 'prod' for cloud env. default is 'prod'
+        - verify_ssl (bool | None): if False - ignore ssl verification and self-sigend urls.
+        """        
+        self._env = env
+        self.verify_ssl = verify_ssl
+        if env not in API_URL:
+            if onprem and env.startswith('http'):
+                self.api_url = env
+            else:
+                self.api_url = API_URL["tenants"].format(tenant=env)
+        else:
+            self.api_url = API_URL[env]
+        self.token = None
+        self.invalid_token_code = 401
+        if not os.path.exists(cred_path):
+            raise Exception(f"credential file doesn't exists: {cred_path}")
+        try:
+            print("load credentials")
+            self.login_sa = self.load_cred(cred_path)
+            print(self.login_sa)
+        except Exception as e:
+            print("failed to load credentials", e)
+            return
+        self.login()
+
+    @retry(tries=3, delay=10)
+    def load_cred(self, path):
+        with open(path, 'r') as fd:
+            return json.load(fd)
+    
+    @retry(tries=3, delay=10)
+    def try_login(self):
+        t = requests.post(f"{self.api_url}/{APIEPS.login}", json=self.login_sa, verify=self.verify_ssl)
+        self.token = t.json()['token']
+        print(self.token)
+    
+    def login(self):
+        """
+        Logs in using the provided credentials, and sets the token.
+
+        """        
+        try:
+            print("try login")
+            self.try_login()
+        except Exception as e:
+            print(e)
+    
+    def safe_call(self, endpoint: str, data: dict, re_login=True, raise_on_failure=False):
+        """
+        Makes a safe POST request to the given API endpoint. if not logged in, or token is expired - automatically reconnect
+
+        Args:
+        - endpoint (str): The API endpoint to make the request to.
+        - data (dict): The JSON data to send in the request.
+
+        Returns:
+        - dict: The response from the API.
+        """            
+        if not self.token:
+            self.login()
+        try:
+            ret = requests.post(f"{self.api_url}/{endpoint}", json=data, headers={"Authorization": f"Bearer {self.token}"}, verify=self.verify_ssl)
+            if ret.status_code == self.invalid_token_code:
+                self.token = None
+                self.login()
+                if re_login:
+                    return self.safe_call(endpoint, data, re_login=False)
+            return ret
+        except:
+            if raise_on_failure:
+                raise
+
+    def safe_call_args(self, endpoint: str, re_login=True, **kwargs):
+        """
+        same as safe_call, with flexible arguments for request
+        """            
+        if not self.token:
+            self.login()
+        try:
+            ret = requests.post(f"{self.api_url}/{endpoint}", headers={"Authorization": f"Bearer {self.token}"}, verify=self.verify_ssl, **kwargs)
+            if ret.status_code == self.invalid_token_code:
+                self.token = None
+                self.login()
+                if re_login:
+                    return self.safe_call(endpoint, re_login=False, **kwargs)
+            return ret
+        except:
+            pass

sumit_sdk/base_task.py

@@ -0,0 +1,89 @@
+from sumit_sdk.api import BaseWrapper 
+import json
+import time
+
+class TaskOperations:
+    TRANSCRIPT = 'transcript'
+    GET_STATUS = 'get_status'
+    TRANSLATE_API = 'translate'
+    TRANSLATE_SUBS = 'translate_subtitles'
+    SUMMARY_API = 'summarize'
+
+class BaseTask(BaseWrapper):
+    """
+    Abstract class to implement API calls for tasks.
+
+    Methods:
+    - execute(): run new task, with custom payload.
+    - build_request(**kwargs): create payload for the request.
+    - get_active_sessions(): Returns the currently active sessions.
+    """
+    _API_VERSION = 'v3'
+
+    def __init__(self, api_instance) -> None:
+        """
+        Initializes the BaseTask.
+
+        Args:
+        - api_instance (APIClient): An instance of the APIClient class.
+        """        
+        super().__init__(api_instance)
+        self._operation = None
+        self._wait_interval = 5
+        self._set_op()
+    
+    def _set_op(self):
+        raise Exception("_set_op not implemented")
+
+    def execute(self, payload):
+        endpoint = f"{self._API_VERSION}/{self._operation}"
+        try:
+            ret = self.api.safe_call(endpoint, payload)
+        except Exception as e:
+            return {
+                'status_code': -1,
+                'content': str(e)
+            }
+        try:
+            ret = ret.json()
+            return ret
+        except:
+            return {
+                'status_code': ret.status_code,
+                'content': ret.content
+            }
+
+    def build_request(self, **kwargs):
+        raise Exception("build_request not implemented")
+
+    def run(self, **kwargs):
+        return self.execute(self.build_request(**kwargs))
+
+    def get_task_status(self, task_id: str):
+        """
+        get the status of async task, by task_id.
+        task_id returned from the response: response['response']['job_id']
+        """
+        ret = self.api.safe_call(TaskOperations.GET_STATUS, {
+            'id': task_id
+        })
+        ret = ret.json()
+        return ret
+    
+    def wait_for_task(self, task_id: str):
+        """
+        blocking function to wait until task is done.
+        alternatively, you can use `callback` to get notified when task is done
+        """
+        finish = False
+        ret = None
+        while not finish:
+            try:
+                ret = self.get_task_status(task_id)
+                finish = ret['response']['progress'] == 100
+                if finish:
+                    break
+            except:
+                pass
+            time.sleep(self._wait_interval)
+        return ret

sumit_sdk/realtime_stt.py

@@ -0,0 +1,181 @@
+from sumit_sdk.api import BaseWrapper 
+from sumit_sdk.utils.socketio_client import SocketClient 
+import time
+import json
+
+class Profiles:
+    default = 'default'  # Est. latency: 3 seconds
+    low_latency = 'low_latency'  # Est. latency: 2.5 seconds
+    lower_latency = 'lower_latency'  # Est. latency: 1.5 seconds
+    accurate = 'accurate'  # Est. latency: 5 seconds
+    very_accurate = 'very_accurate'  # Est. latency: 7 seconds
+
+class VadProfile:
+    default = 'default'
+    high = 'high'
+    low = 'low'
+    very_low = 'very_low'
+    off = 'off'
+
+class BufferMode:
+    default = 'accumulate'
+    switch = 'switch'
+
+class RealtimeSTT(BaseWrapper):
+    """
+    Manages realtime sessions.
+
+    Attributes:
+    - sessions (dict): A dictionary to store session IDs and their corresponding data, including URLs for web socket communication.
+
+    Methods:
+    - start_session(): Starts a new session and stores its details.
+    - stop_session(session_id): Stops an existing session.
+    - get_active_sessions(): Returns the currently active sessions.
+    """
+
+    _START_EP = "realtime/start"
+    _STOP_EP = "realtime/stop"
+    _STATUS_EP = "realtime/get_status"
+
+    def __init__(self, api_instance) -> None:
+        """
+        Initializes the RealtimeSTT.
+
+        Args:
+        - api_instance (APIClient): An instance of the APIClient class.
+        """        
+        super().__init__(api_instance)
+        self.sessions = {}
+        self.current_session = None
+        self.transcript_callback = None
+
+    def start_session(self, transcript_callback, language:str=None, profile:str=None, vad_profile:str=None, buffer_mode=None, _add_params=None) -> dict:
+        """
+        Starts a new session and stores its details.
+
+        Args:
+        - transcript_callback: callback function to notify when transcription received.
+        - language (str): language code. default is he-IL (Hebrew)
+        - profile (str): one of `realtime_stt.Profiles` - control the latency and accuracy of the transcription. 
+            usually the higher the latency, higher the accuracy 
+        - vad_profile (str): one of `realtime_stt.VadProfiles` - control the VAD thresholds to avoid non-speech transcription. 
+        - buffer_mode (str): one of `realtime_stt.BufferMode` - control the buffering method for the speech context.
+
+        Returns:
+        - dict: containing the session ID and its corresponding URL.
+        """      
+        req = {}  
+        if language:
+            req['lang'] = language
+        if profile:
+            req['profile'] = profile
+        if vad_profile:
+            req['vad_profile'] = vad_profile
+        if buffer_mode:
+            req['buffer_mode'] = buffer_mode
+        if _add_params:
+            req.update(_add_params)
+        print(req)
+        data = self.api.safe_call(RealtimeSTT._START_EP, req).json()
+        session_id = data.get("session_id")
+        self.sessions[session_id] = data
+        self.current_session = session_id
+        self.transcript_callback = transcript_callback
+        return data
+
+    def _inject_session(self, session_id, url, transcript_callback) -> dict:
+        """
+        Starts a new session and stores its details.
+
+        Returns:
+        - dict: containing the session ID and its corresponding URL.
+        """        
+        # data = self.api.safe_call(RealtimeSTT._START_EP, {}).json()
+        self.sessions[session_id] = {"id": session_id, "endpoint": url}
+        self.current_session = session_id
+        self.transcript_callback = transcript_callback
+        return self.sessions[session_id]
+
+    def stop_session(self, session_id: str=None):
+        """
+        Stops an existing session.
+
+        Args:
+        - session_id (str): The ID of the session to stop. if None - get the last created session
+        """
+        if not session_id:
+            session_id = self.current_session
+        ret = self.api.safe_call(RealtimeSTT._STOP_EP, {"id": session_id})
+        if ret:
+            ret = ret.json()
+        else:
+            raise Exception("failed to stop session")
+        if session_id in self.sessions:
+            self.sessions.pop(session_id)
+        if ret.get('success') and session_id == self.current_session:
+            self.current_session = None
+        return ret
+
+    def get_active_sessions(self) -> dict:
+        """
+        Returns the currently active sessions ids.
+
+        Returns:
+        - dict: A dictionary containing the session IDs and their corresponding URLs.
+        """
+        return self.sessions
+    
+    def _wait_ready(self, session_id: str):
+        ready = False
+        wait_time = 30
+        while not ready:
+            ret = self.api.safe_call(RealtimeSTT._STATUS_EP, {"id": session_id})
+            if ret:
+                ret = ret.json()
+            else:
+                continue
+            ready = ret.get('status', {}).get('transcript')
+            if not ready:
+                # limit the number of calls to sumit-api to avoid `quota exceed` block
+                # in future release it's will replaces with events
+                time.sleep(wait_time)
+                if wait_time >= 10:
+                    wait_time -= 5
+
+    def connect(self, session_id: str=None) -> SocketClient:
+        """
+        connect to streaming end point for realtime transcription.
+
+        Args:
+        - session_id (str): The ID of the session to stop. if None - get the last created session
+
+        Returns:
+        SocketClient instance for async streaming to the realtime server
+        """
+        if not session_id:
+            session_id = self.current_session
+        print("monitor instance state...")
+        self._wait_ready(session_id)
+        url = self.sessions[session_id]["endpoint"]
+        print(f"ready, init socket client: {url}")
+        sock = SocketClient("https://" + url)
+        sock.register_callback('txt', self._parse_json)
+        sock.connect()
+        return sock
+    
+    def send(self, sock: SocketClient, data):
+        """
+        send audio chunk to transcript
+
+        Args:
+        - sock (SocketClient): socket instance to use. received from `connect` method
+        - data: base64 bytes to send
+
+        """        
+        sock.send_message('data', data)
+
+    def _parse_json(self, msg):
+        m = json.loads(msg)
+        if self.transcript_callback:
+            self.transcript_callback(m)