socaity 0.0.0__py3-none-any.whl

socaity/__init__.py

@@ -0,0 +1,3 @@
+# includes clientAPIs and simple APIs
+from socaity.api import *
+from socaity.core import Job, ClientAPI, create_client

socaity/api/__init__.py

@@ -0,0 +1,18 @@
+"""
+The references to ClientAPIs and SimpleAPIs
+
+# CLIENT APIs
+    A ClientAPI is a class that contains the logic to pre and post_process a request to an endpoint.
+    It is a wrapper around the client and job classes.
+    Instead of using clients and jobs directly, you can use the predefined "model" ClientAPI classes to do the work.
+
+# SIMPLE APIs
+    A SimpleAPI is a wrapper around a ClientAPI.
+    It initiates the ClientAPI with the correct endpoint and model name, and provides a simple function to run the job.
+
+"""
+# Defined ClientAPIs
+from .audio import *
+
+# This references to all simple api functions
+from .simple_api import *

socaity/api/audio/__init__.py

@@ -0,0 +1 @@
+from .bark import Bark

socaity/api/audio/bark.py

@@ -0,0 +1,89 @@
+from typing import Union
+
+from socaity.core.job import Job
+from socaity.core.client_api import ClientAPI
+from socaity.globals import ModelType, EndPointType
+from socaity.utils.audio import audio_from_bytes
+from socaity.utils.utils import get_function_parameters_as_dict
+
+
+class Bark(ClientAPI):
+    """
+    With Bark (adapted by socAIty) you can:
+    - Convert text to natural sounding speech with predefined speakers in 100+ languages.
+    - Clone voices by creating embeddings from audio files
+    - Convert voice2voice aka voice cloning
+
+    For available speakers visit:
+    - Official page of suno: https://suno-ai.notion.site/8b8e8749ed514b0cbf3f699013548683?v=bc67cff786b04b50b3ceb756fd05f68c
+    - For other speakers visit the socaity references.
+
+    Bark is developed by Suno.ai. With this client you interact with the Bark adaptation of socAIty.
+    For the repos visit: https://github.com/SocAIty/BarkVoiceCloneREST
+    """
+    def __init__(self, endpoint_type: Union[EndPointType, str] = EndPointType.REMOTE):
+        super().__init__(
+            model_type=ModelType.TEXT2VOICE,
+            model_name="bark",
+            endpoint_type=endpoint_type
+        )
+
+    def validate_params(
+            self,
+            text: str | list,
+            voice_name_or_embedding_path: str = "en_speaker_3",
+            *args, **kwargs) -> (bool, str):
+        """
+        Method is executed before a job is created.
+        Returns True if the parameters are valid, otherwise False.
+        """
+        return True, None
+
+    def _pre_process(self, text: str | list, *args, **kwargs):
+        # add text again to args
+        _kwargs = get_function_parameters_as_dict(self.run, locals(), kwargs)
+
+        # attempt to make it batched.
+        if isinstance(text, str):
+            _kwargs["text"] = [text]
+
+        return _kwargs
+
+    def _post_process(self, result, *args, **kwargs):
+        return audio_from_bytes(result, save_file_path=None)
+
+    def __call__(
+        self,
+        text: str | list,
+        voice_name_or_embedding_path: str = "en_speaker_3",
+        semantic_temp=0.7,
+        semantic_top_k=50,
+        semantic_top_p=0.95,
+        coarse_temp=0.7,
+        coarse_top_k=50,
+        coarse_top_p=0.95,
+        fine_temp=0.5,
+        **kwargs
+    ):
+        # just reuse args to easy pass them to super
+        _kwargs = get_function_parameters_as_dict(self.run, locals(), kwargs)
+
+        return super().__call__(**_kwargs)
+
+    def run(
+        self,
+        text: str | list,
+        voice_name_or_embedding_path: str = "en_speaker_3",
+        semantic_temp=0.7,
+        semantic_top_k=50,
+        semantic_top_p=0.95,
+        coarse_temp=0.7,
+        coarse_top_k=50,
+        coarse_top_p=0.95,
+        fine_temp=0.5,
+        **kwargs
+    ) -> Job:
+        # just reuse args to easy pass them to super
+        _kwargs = get_function_parameters_as_dict(self.run, locals(), kwargs)
+        return self.__call__(**_kwargs)
+

socaity/api/simple_api.py

@@ -0,0 +1,13 @@
+from socaity.api.audio import Bark
+from socaity.globals import EndPointType
+
+
+def text2speech(text, *args, **kwargs) -> (bytes, int):
+    bark = Bark(endpoint_type=EndPointType.REMOTE)
+    return bark.run(text, *args, **kwargs)
+
+def face2face():
+    pass
+
+def voice2voice():
+    pass

socaity/core/__init__.py

@@ -0,0 +1,6 @@
+# references to the __init__.py file in the Client module
+from .client import *
+# others
+from .client_api import ClientAPI
+from .endpoint import EndPoint, LocalEndPoint, RemoteEndPoint, EndPointType
+from .job import Job, JobStatistics

socaity/core/client/__init__.py

@@ -0,0 +1,4 @@
+from .client import Client
+from .local_client import LocalClient
+from .remote_client import RemoteClient
+from .client_factory import create_client

socaity/core/client/client.py

@@ -0,0 +1,53 @@
+from socaity.core.endpoint import EndPoint
+from socaity.core.job import Job
+import requests
+
+class Client:
+    """
+    A Client handles the requests to an API.
+    """
+
+    def __init__(self, endpoint: EndPoint):
+        self.endpoint = endpoint
+
+        self._job_queue = []
+        self._results = []
+
+    def __call__(self, *args, **kwargs):
+        return self.run(*args, **kwargs)
+
+    def prepare_payload(self, job: Job) -> Job:
+        """
+        Subclass this method to implement your own payload preparation.
+        This is for example needed in web requests to have post, get and file parameters.
+        """
+        return job
+
+    def request(self, job: Job):
+        """
+        The method to make the request to the API.
+        Subclass this method.
+        """
+        raise NotImplementedError("Subclass the request method")
+
+    def run(self, job: Job, *args, **kwargs) -> Job:
+        """
+        Run the job.
+        """
+        # call pre_process function of client api (which is referenced in the job)
+        job.pre_process_params()
+        # obtain post, get, and files for web request
+        self.prepare_payload(job)
+        # make the request
+        print(f"Requesting {self.endpoint.endpoint_name} with job {job.job_statistics.created}")
+        endpoint_result = self.request(job)  # result is also stored in the job
+        # call post_process function of client api
+        job.post_process_result(endpoint_result)
+        print(f"Job {job.job_statistics.created} finished in {job.job_statistics.get_execution_time()} seconds.")
+        return job
+
+    def run_async(self):
+        pass
+
+
+

socaity/core/client/client_factory.py

@@ -0,0 +1,46 @@
+from typing import Union
+
+from socaity.core.client.local_client import LocalClient
+from socaity.core.client.remote_client import RemoteClient
+from socaity.globals import ModelType, EndPointType
+from socaity.registry.registry import get_endpoint, ACTIVE_CLIENT_REGISTRY
+
+
+def create_client(
+        model_type: Union[ModelType, str, None] = None,
+        model_name: str = None,
+        endpoint_type:  Union[EndPointType, str] = EndPointType.REMOTE,
+        provider: str = "socaity",
+) -> Union[LocalClient, RemoteClient]:
+    """
+    Create a client to interact with an API.
+    :param model_type: for example "text2speech"
+    :param model_name: for example "bark"
+    :param endpoint_type: for example "remote"
+    :param provider: for example "socaity"
+    :return: a client to interact with the API
+    """
+    clients = {
+        EndPointType.LOCAL: LocalClient,
+        EndPointType.REMOTE: RemoteClient
+    }
+
+    endpoint = get_endpoint(model_type=model_type, model_name=model_name, endpoint_type=endpoint_type, provider=provider)
+
+    # check if the client is already created and return from the registry if it is the case
+    client = ACTIVE_CLIENT_REGISTRY.get_client(endpoint, default_return_value=None)
+    if client is not None:
+        return client
+
+
+    # create a new client
+    if endpoint.endpoint_type in clients:
+        client = clients[endpoint.endpoint_type](endpoint)
+    else:
+        print(f"Endpoint type {endpoint_type} not supported. Defaulting to remote.")
+        client = RemoteClient(endpoint)
+
+    # add the client to the registry
+    ACTIVE_CLIENT_REGISTRY.add_active_client(client)
+
+    return client

socaity/core/client/local_client.py

@@ -0,0 +1,104 @@
+import time
+import os
+from subprocess import Popen, CREATE_NEW_CONSOLE
+from enum import Enum
+
+from socaity.core.job import Job
+from socaity.core.client.remote_client import RemoteClient, web_request
+from socaity.core.endpoint import LocalEndPoint
+
+class LocalServerStatus(Enum):
+    OK = "ok"
+    NOT_OK = "not ok"
+    TIMEOUT = "timeout"
+
+
+
+class LocalClient(RemoteClient):
+    def __init__(self, endpoint: LocalEndPoint,
+                 start_server_from_bat_file: bool = True,
+                 server_not_reachable_timeout: int = 60
+                 ):
+        super().__init__(endpoint)
+        self.endpoint = endpoint
+        self.is_running = False
+        self.__start_server_from_bat_file = start_server_from_bat_file
+        self.server_not_reachable_timeout = server_not_reachable_timeout
+
+    def _start_server(self):
+        if not self.is_running:
+            print("starting server")
+
+            # make a test request to check if the server is running
+            if self.__check_server_status_ok():
+                return True
+
+            if not os.path.isfile(self.endpoint.start_bat_path):
+                raise ValueError(
+                    f"start_server.bat not found in {self.endpoint.start_bat_path}. Is Bark installed?")
+
+            # start the server in a new console
+            print(f"starting server {self.endpoint.start_bat_path}")
+            self.process = Popen(self.endpoint.start_bat_path,
+                                 creationflags=CREATE_NEW_CONSOLE,
+                                 cwd=os.path.dirname(self.endpoint.start_bat_path)
+                                 )
+
+            status = self._wait_for_ok_of_server()
+
+            return status
+
+
+    def _wait_for_ok_of_server(self):
+        # print("wait until bark is ready")
+        start_open = time.time()
+
+        ## not managed to print the console output in pipe don't know why it doesnt work.
+        while True:
+            status = self.__check_server_status_ok()
+            if status:
+                print("server is running")
+                break
+            elif int(time.time() - start_open) >= self.server_not_reachable_timeout:
+                self.is_running = False
+                status = LocalServerStatus.TIMEOUT
+                print("server start timed out")
+                break
+            else:
+                time.sleep(1)  # wait one sec
+
+        return status
+
+    def stop_server(self):
+        if self.process is not None:
+            self.process.terminate()
+            self.is_running = False
+
+    def __check_server_status_ok(self) -> LocalServerStatus:
+        """
+        Check if the server is running and responding with "ok"
+        """
+        url = self.endpoint.service_url + "/status"
+        status, error = web_request(url=url)
+        if "ok" in str(status).lower() and not error:
+            self.is_running = True
+            return LocalServerStatus.OK
+        else:
+            return LocalServerStatus.NOT_OK
+
+
+    def request(self, job: Job):
+        """
+        Subclass of RemoteClient.request
+        :param job: the job with the payload to send
+        """
+        # start the server if not running
+        if not self.is_running:
+            if self.__start_server_from_bat_file:
+                self._start_server()
+            else:
+                raise ValueError("Server is not running. Please start the server first.")
+
+        # make the request
+        result = super().request(job)
+        return result

socaity/core/client/remote_client.py

@@ -0,0 +1,104 @@
+from typing import Union,Tuple
+import requests
+from requests import JSONDecodeError
+
+from socaity.core.client.client import Client
+from socaity.core.endpoint import RemoteEndPoint
+from socaity.core.job import Job
+
+
+def web_request(
+        url: str,
+        get_params: dict = None,
+        post_params: dict = None,
+        files: dict = None) -> Tuple[object, Union[str, None]]:
+    """
+    Request an hosted API.
+    :param url: The url of the API
+    :param get_params: The parameters to be sent in the GET request
+    :param post_params: The parameters to be sent in the POST request
+    :param files: The files to be sent in the request.
+    :return: result, error_msg (or None if nor error occurred)
+    """
+    # add get parameters to url
+    if get_params:
+        url += "?"
+        for k, v in get_params:
+            url += f"{k}={v}&"
+        url = url[:-1]
+
+    # send request
+    error = None
+    res = None
+    try:
+        response = requests.post(url, params=post_params, files=files)
+        if response.status_code == 500:
+            print(f"API {url} call error: {response.content}")
+            return response.content
+        if response.headers.get("content-type") in ["audio/wav", "image/png", "image/jpg", "octet-stream"]:
+            res = response.content
+        else:
+            res = response.json()
+    except JSONDecodeError as e:
+        print(f"Response of API {url} is not JSON format. Intended?")
+        error = str(e)
+    except Exception as e:
+        error = str(e)
+        print(f"API {url} call error: {str(e)}")
+
+    return res, error
+
+class RemoteClient(Client):
+    """
+    Used to interact with remote APIs. Implements Authentication and Authorization.
+    It creates Jobs which are then run in a thread.
+    The jobs have the required logic to pre and postprocess the requests.
+
+    1. Get the token
+    2. Make the request
+    """
+    def __init__(self, endpoint: RemoteEndPoint):
+        super().__init__(endpoint)
+        self.endpoint = endpoint
+
+    def prepare_payload(self, job: Job) -> Job:
+        """
+        Moves params for post, get, and files.
+        """
+        # get the named parameters
+        payload = {
+            "post_params": {k: v for k, v in job.raw_payload.items() if k in self.endpoint.post_params},
+            "get_params": {k: v for k, v in job.raw_payload.items() if k in self.endpoint.get_params},
+            "files": {k: v for k, v in job.raw_payload.items() if k in self.endpoint.files}
+        }
+
+        # add remaining parameters to post
+        remaining_params = {
+            k: v for k, v in job.raw_payload.items()
+            if k not in payload["post_params"]
+            and k not in payload["files"]
+            and k not in payload["get_params"]
+        }
+        payload["post_params"].update(remaining_params)
+
+        job.payload = payload
+
+        return job
+
+    def request(self, job: Job) -> Union[dict, bytes, str, object, None]:
+        """
+        :param job: the job with the payload to send
+        :return: the result of the request to the remote API
+        """
+        url = self.endpoint.service_url
+        url = url if self.endpoint.endpoint_name is None else f"{url}/{self.endpoint.endpoint_name}"
+
+        res, error = web_request(url, job.payload["get_params"], job.payload["post_params"], job.payload["files"])
+
+        if error:
+            raise Exception(f"API {url} call error: {error}")
+
+        return res
+
+    def run(self, job: Job, *args, **kwargs) -> Job:
+        return super().run(job, *args, **kwargs)

socaity/core/client_api.py

@@ -0,0 +1,66 @@
+from typing import Union
+
+from socaity.core.client.client_factory import create_client
+from socaity.globals import ModelType, EndPointType
+from socaity.core.job import Job
+
+
+class ClientAPI:
+    def __init__(self,
+                 model_type: ModelType,
+                 model_name: str,
+                 endpoint_type: Union[EndPointType, str] = EndPointType.REMOTE
+                 ):
+        self.model_type = model_type
+        self.model_name = model_name
+        self.endpoint_type = endpoint_type
+        self.client = create_client(model_type=model_type, model_name=model_name, endpoint_type=endpoint_type)
+
+    def validate_params(self, *args, **kwargs) -> (bool, str):
+        """
+        Method is executed before a job is created.
+        Validate the parameters passed to the job before job is created.
+        :return: validation_success, error_message
+        Subclass this method to implement your own validation.
+        """
+        return True, None
+
+    def _pre_process(self, *args, **kwargs):
+        """
+        This method is called before the job is executed.
+        Subclass this method if you want to do some preprocessing of the args and kwargs.
+        """
+        return args, kwargs
+
+    def _post_process(self, *args, **kwargs):
+        """
+        This method is called after the job is executed.
+        Subclass this method if you want to do some postprocessing.
+        """
+        pass
+
+    def __call__(self, **kwargs) -> Union[Job, None]:
+        """
+        Run the job with the given parameters.
+        Subclass this method if you want type hinting. But don't forget to call super().__call__(..)
+        :kwargs: The parameters for running the job. Note only named are further passed to the job. Transform args to kwargs
+        """
+        valid, error = self.validate_params(**kwargs)
+        if not valid:
+            print(f"Validation of params failed before job execute: {error}. Job will not be created.")
+            return None
+
+        # The parameters for running the job are in *args and **kwargs and then stored in the job itself.
+        job = Job(self._pre_process, self._post_process, **kwargs)
+        result = self.client.run(job)
+        #try:
+        #    result = self.client.run(job)
+        #except Exception as e:
+        #    print(f"Job execution failed: {e}.")
+        #    return None
+
+        return result
+
+    def run(self, *args, **kwargs):
+        """ Please subclass the class to implement type hinting."""
+        return self(*args, **kwargs)

socaity/core/endpoint.py

@@ -0,0 +1,73 @@
+from socaity.globals import EndPointType, ModelType
+
+class EndPoint:
+    """
+    An endpoint contains the information to connect to a model hosted on a provider (Remote, Local or Decentralized).
+    """
+    def __init__(
+        self,
+        model_type: ModelType,
+        model_name: str,
+        endpoint_type: EndPointType,
+        endpoint_name: str = None,
+        provider: str = None,
+        post_params: list = None,
+        get_params: list = None,
+        files: list = None,
+        *args,
+        **kwargs
+    ):
+        """
+        :param model_type: The type of the model (for example ModelType.TEXT2VOICE)
+        :param model_name: The name of the model (for example "bark")
+        :param endpoint_type: The type of the endpoint (for example EndPointType.REMOTE)
+        :
+        :param provider: The provider of the model (for example "socaity")
+        :param post_params: The parameters to be sent in the POST request
+        :param get_params: The parameters to be sent in the GET request
+        :param files: The files to be sent in the request.
+        All parameters in a request which are not defined in post, get, or files are default as post parameters.
+        """
+
+        self.model_name = model_name
+        self.model_type = model_type
+        self.endpoint_type = endpoint_type
+        self.endpoint_name = endpoint_name
+        self.provider = provider
+
+        # initiating empty lists if not given to avoid errors
+        self.post_params = post_params if post_params is not None else []
+        self.get_params = get_params if get_params is not None else []
+        self.files = files if files is not None else []
+
+    def __str__(self):
+        return f"{self.model_type.value}_{self.model_name}_{self.endpoint_type.value}_{self.provider}"
+
+
+
+class RemoteEndPoint(EndPoint):
+    def __init__(self, model_type: ModelType, model_name: str, service_url: str, endpoint_name: str, *args, **kwargs):
+        super().__init__(model_type=model_type, model_name=model_name, endpoint_type=EndPointType.REMOTE,
+                         endpoint_name=endpoint_name,
+                         *args, **kwargs)
+        self.service_url = service_url
+        self.endpoint_name = endpoint_name
+
+
+class LocalEndPoint(EndPoint):
+    def __init__(self, service_url: str, endpoint_name: str, start_bat_path: str = "", *args, **kwargs):
+        super().__init__(service_url=service_url, endpoint_name=endpoint_name, endpoint_type=EndPointType.LOCAL,
+                         *args, **kwargs)
+        self.service_url = service_url
+        self.start_bat_path = start_bat_path
+
+
+class SocaityEndpoint(RemoteEndPoint):
+    """ Helper class with predifined URLS to define the SOCAITY endpoints. """
+    def __init__(self, model_type: ModelType, model_name: str, *args, **kwargs):
+        self.service_url = f"https://socaity.ai/api/"
+        self.endpoint_name = f"{model_type.value}/{model_name}"
+        super().__init__(model_type=model_type, model_name=model_name,
+                         service_url=self.service_url, endpoint_name=self.endpoint_name,
+                         provider="socaity", *args, **kwargs)
+

socaity/core/job.py

@@ -0,0 +1,85 @@
+import time
+
+
+class JobStatistics:
+    """
+    Stores the time when the different stages of the job were executed.
+    """
+    def __init__(self):
+        self.created = time.time()
+        self.pre_processing_started = None
+        self.pre_processing_ended = None
+        self.request_send = None
+        self.request_result_received = None
+        self.post_processing_started = None
+        self.post_processing_ended = None
+
+    def get_execution_time(self):
+        """
+        The time it took to execute the job in seconds.
+        """
+        return self.post_processing_ended - self.pre_processing_started
+
+
+class Job:
+    """
+    A job contains the:
+     - the payload to handle a request.
+     - references to the pre and post processing functions.
+     - the result of the request.
+     - the statistics and execution times of the job.
+    """
+    def __init__(self,
+                 pre_process_func: callable = None,
+                 post_process_func: callable = None,
+                 **kwargs):
+        """
+        :param pre_process_func: A function that pre_processes the request parameters, before sending the request.
+        :param post_process_func: A function that post_processes the result of the request, before returning it.
+        :param kwargs: The named parameters of the request. (Note: args where transformed to kwargs in the clientAPI.)
+
+        If parameters are not named in post, get, or files, they are default sent as post parameters.
+        """
+
+        self.preprocess_func = pre_process_func
+        self.post_process_func = post_process_func
+        self.job_statistics = JobStatistics()
+        self.result = None
+
+        # prepare payload
+        self.raw_payload = kwargs  # will be modified in job.preprocess_params in client.run
+        self.payload = None  # will be prepared for post, get, and file params in client before request is sent
+
+    def get_payload(self):
+        return self.payload
+
+    def pre_process_params(self):
+        """
+        This function is called before the request is sent.
+        Use it to modify the request payload parameters if needed.
+        It is better to do it here than in the init function because this method will be called threaded.
+        :param kwargs:
+        :return:
+        """
+        if self.preprocess_func is not None:
+            self.job_statistics.pre_processing_started = time.time()
+            self.raw_payload = self.preprocess_func(**self.raw_payload)
+            self.job_statistics.pre_processing_ended = time.time()
+
+        return self.raw_payload
+
+    def post_process_result(self, result, *args, **kwargs):
+        """
+        The result of the request is the raw response from the server.
+        Use this method to process the result before returning it.
+        :param result:
+        :param kwargs:
+        :return:
+        """
+        if self.post_process_func is not None:
+            self.job_statistics.post_processing_started = time.time()
+            self.result = self.post_process_func(result, *args, **kwargs)
+            self.job_statistics.post_processing_ended = time.time()
+
+        return self
+