yait-aichain 0.1__tar.gz

yait_aichain-0.1/PKG-INFO

@@ -0,0 +1,5 @@
+Metadata-Version: 2.1
+Name: yait-aichain
+Version: 0.1
+Summary: A simple Python library designed to wrap and unify AI functions from various popular services
+Author: YAIT

yait_aichain-0.1/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

yait_aichain-0.1/setup.py

@@ -0,0 +1,9 @@
+from setuptools import setup, find_packages
+
+setup(
+    name='yait-aichain',
+    version='0.1',
+    description='A simple Python library designed to wrap and unify AI functions from various popular services',
+    author='YAIT',
+    packages=find_packages(),
+)

yait_aichain-0.1/yait-aichain/_client.py

@@ -0,0 +1,372 @@
+import urllib3
+import json
+import base64
+
+from _constants import (
+    DEFAULT_TIMEOUT,
+    MAX_RETRY_DELAY,
+    DEFAULT_MAX_RETRIES,
+    INITIAL_RETRY_DELAY,
+    DEFAULT_CHATMODEL_TEMPERATURE,
+    DEFAULT_MAX_TOKENS
+)
+
+class BaseClient:
+    _client: urllib3.PoolManager
+    _base_url: str
+    _tiemout: urllib3.Timeout
+    _retries: urllib3.Retry
+
+    def __init__(self, base_url: str, timeout: urllib3.Timeout = DEFAULT_TIMEOUT, retries: urllib3.Retry = DEFAULT_MAX_RETRIES):
+        self._base_url = base_url
+        self._client = urllib3.PoolManager(timeout=timeout, retries=retries)
+
+    def get(self, path: str, headers: dict = None):
+        response = self._client.request('GET', self._base_url + path, headers = headers)
+        if response.status == 200:
+            return response.data.decode('utf-8')
+        else:
+            return None
+
+
+    def download(self, headers: dict = None):
+        response = self._client.request('GET', self._base_url, headers = headers)
+
+        if response.status == 200:
+            return {
+                "data": response.data,
+                "media_type": response.headers['Content-Type']
+            }
+
+        else:
+            return None
+
+    def post(self, path: str, data: dict = None, formdata: dict = None, headers: dict = None):            
+            try:
+                if data:
+                    response = self._client.request('POST', self._base_url + path, body = json.dumps(data), headers = headers)
+                elif formdata:
+                    response = self._client.request('POST', self._base_url + path, fields = formdata, headers = headers)
+                else:
+                    return None
+
+                if response.status == 200:
+                    return response.data
+                else:
+                    e = json.loads(response.data.decode('utf-8'))
+                    print(f"An error occurred: {str(e)}")                    
+                    return None
+            except Exception as e:
+                print(f"An error occurred: {str(e)}")
+                return None
+    
+class OpenAIClient(BaseClient):
+    _model: str
+
+    def __init__(self, api_key: str, model: str):
+        super().__init__(
+            base_url = 'https://api.openai.com',
+            timeout = DEFAULT_TIMEOUT,
+            retries = DEFAULT_MAX_RETRIES
+        )
+        self._api_key = api_key
+        self._model = model
+
+    def completion(self, messages: list):
+
+        body = {
+            "model": self._model,
+            "messages": messages,
+            "temperature": DEFAULT_CHATMODEL_TEMPERATURE
+        }
+
+        responce = self.post(
+            '/v1/chat/completions',
+            data = body,
+            headers = {
+                'Authorization': 'Bearer ' + self._api_key,
+                'Content-Type': 'application/json'
+            }
+        )
+
+        return json.loads(responce.decode('utf-8')) if responce is not None else None
+
+    def generation(self, messages: object, options: dict = None):
+
+        response_format =  options['response_format'] if (options is not None) and ('response_format' in options) else "url"
+
+        body = {
+            "prompt" : messages[0]['content'],
+            "n" : 1,
+            "model" : self._model,
+            "size" : "1024x1024",
+            "response_format" : response_format
+        }
+
+        responce = self.post(
+            '/v1/images/generations',
+            data = body,
+            headers = {
+                'Authorization': 'Bearer ' + self._api_key,
+                'Content-Type': 'application/json'
+            }
+        )
+
+        if responce is not None: 
+            if response_format == "b64_json":                
+                return {"type" : "image", "data" : base64.b64decode(json.loads(responce)["data"][0]["b64_json"])}
+            else:
+                return {"type" : "url", "data" : json.loads(responce.decode('utf-8'))["data"][0]["url"]}                
+        else: 
+            None    
+
+    def embeddings(self, input: str):
+
+        response = self.post(
+            '/v1/embeddings',
+            data = { "model": self._model, "input": input},
+            headers = {
+                'Authorization': 'Bearer ' + self._api_key,
+                'Content-Type': 'application/json'
+            }
+        )
+
+        return json.loads(response.decode('utf-8'))['data'][0]['embedding'] if response is not None else None
+    
+class MistralAIClient(BaseClient):
+    _model: str
+
+    def __init__(self, api_key: str, model: str):
+        super().__init__(
+            base_url = 'https://api.mistral.ai',
+            timeout = DEFAULT_TIMEOUT,
+            retries = DEFAULT_MAX_RETRIES
+        )
+        self._api_key = api_key
+        self._model = model
+
+    def completion(self, messages: list):
+
+        body = {
+            "model": self._model,
+            "messages": messages,
+            "temperature": DEFAULT_CHATMODEL_TEMPERATURE
+        }
+
+        responce = self.post(
+            '/v1/chat/completions',
+            data = body,
+            headers = {
+                'Authorization': 'Bearer ' + self._api_key,
+                'Content-Type': 'application/json'
+            }
+        )
+
+        return json.loads(responce.decode('utf-8')) if responce is not None else None
+
+class YandexClient(BaseClient):
+    _model: str
+
+    def __init__(self, api_key: str, catalogId: str, model: str):
+        super().__init__(
+            base_url = 'https://llm.api.cloud.yandex.net',
+            timeout = DEFAULT_TIMEOUT,
+            retries = DEFAULT_MAX_RETRIES
+        )
+        self._api_key = api_key
+        self._model = model
+        self.catalogId = catalogId
+
+    def __prepareBody(self, messages):
+        for message in messages:
+            message['text'] = message.pop('content')
+
+        return {
+            "modelUri": f"gpt://{self.catalogId}/{self._model}/latest",
+            "completionOptions": {
+                "stream": False,
+                "temperature": DEFAULT_CHATMODEL_TEMPERATURE,
+                "maxTokens": DEFAULT_MAX_TOKENS
+            },
+            "messages": messages
+        }
+
+    def completion(self, messages: list):        
+
+        responce = self.post(
+            '/foundationModels/v1/completion',
+            data = self.__prepareBody(messages),
+            headers = {
+                'Authorization': 'Api-Key ' + self._api_key,
+                'Content-Type': 'application/json'
+            }
+        )
+        
+        return json.loads(responce.decode('utf-8')) if responce is not None else None
+
+class StabilityAIClient(BaseClient):
+    _model: str
+
+    def __init__(self, api_key: str, model: str):
+        super().__init__(
+            base_url = 'https://api.stability.ai/v2beta',
+            timeout = DEFAULT_TIMEOUT,
+            retries = DEFAULT_MAX_RETRIES
+        )
+        self._api_key = api_key
+        self._model = model
+
+    def generation(self, messages: object, options: dict = None):
+
+        fileds = {
+            "prompt": messages[0]['content']
+        }
+
+        if self._model == "core":
+            url = '/stable-image/generate/core'
+        else:
+            url = '/stable-image/generate/sd3'
+            fileds['model'] = self._model
+
+        
+        if options is not None:
+            if 'output_format' in options: fileds['output_format'] = options['output_format']
+            if 'seed' in options: fileds['seed'] = options['seed']
+            if 'style' in options: fileds['style_preset'] = options['style']
+            if 'output_format' in options: fileds['output_format'] = options['output_format']
+            if 'aspect_ratio' in options: fileds['aspect_ratio'] = options['aspect_ratio']
+       
+        responce = self.post(
+            url,
+            formdata = fileds,
+            headers = {
+                'Authorization': 'Bearer ' + self._api_key,
+                'accept': 'image/*'
+            }
+        )
+
+        if responce is not None:
+            return {"type" : "image", "data" : responce}
+        else:
+            return None
+
+class AnthropicClient(BaseClient):
+    _model: str
+
+    def __init__(self, api_key: str, model: str):
+        super().__init__(
+            base_url = 'https://api.anthropic.com',
+            timeout = DEFAULT_TIMEOUT,
+            retries = DEFAULT_MAX_RETRIES
+        )
+        self._api_key = api_key
+        self._model = model
+
+    def __prepareBody(self, messages):
+                
+        systemPrompt = None
+        for idx, message in enumerate(messages):
+            if message['role'] == 'system':
+                systemPrompt = message['content']
+                del messages[idx]
+                break
+
+        body = {
+            "model": self._model,
+            "messages": messages,
+            "max_tokens": DEFAULT_MAX_TOKENS
+        }
+        if systemPrompt is not None: body["system"] = systemPrompt                    
+        return body
+
+    def completion(self, messages: list):
+        responce = self.post(
+            '/v1/messages',
+            data = self.__prepareBody(messages),
+            headers = {
+                'x-api-key': self._api_key,
+                'Content-Type': 'application/json',
+                'anthropic-version': '2023-06-01'
+            }
+        )
+
+        return json.loads(responce.decode('utf-8')) if responce is not None else None
+    
+class GoogleAIClient(BaseClient):
+    _model: str
+
+    def __init__(self, api_key: str, model: str):
+        super().__init__(
+            base_url = 'https://generativelanguage.googleapis.com/v1beta',
+            timeout = DEFAULT_TIMEOUT,
+            retries = DEFAULT_MAX_RETRIES
+        )
+        self._api_key = api_key
+        self._model = model
+
+    def __prepareBody(self, messages):
+        
+        systemPrompt = None
+        for idx, message in enumerate(messages):
+            if message['role'] == 'system':
+                systemPrompt = message['content']
+                del messages[idx]
+                break
+
+        isSystemPromptApplicable = True
+        for message in messages:
+            if message['role'] == 'user':
+                message['parts'] = [] if systemPrompt is None and isSystemPromptApplicable else [{"text": systemPrompt}]
+                isSystemPromptApplicable = False
+                if message['content'] is not None and type(message['content']) is list:
+                    message['parts'] = message.pop('content')                                                           
+                else:
+                    message['parts'].append({"text": message.pop('content')})
+            
+            if message['role'] == 'assistant':
+                message['role'] = 'model'
+                message['parts'] = [{"text": message.pop('content')}]
+
+        return {            
+            "contents": message
+        }
+
+    def completion(self, messages: list):
+        
+        responce = self.post(
+            f'/models/{self._model}:generateContent?key={self._api_key}',
+            data = self.__prepareBody(messages),
+            headers = {
+                'Content-Type': 'application/json',                
+            }
+        )
+
+        return json.loads(responce.decode('utf-8')) if responce is not None else None
+    
+class VoyageAIClient(BaseClient):
+    _model: str
+
+    def __init__(self, api_key: str, model: str):
+        super().__init__(
+            base_url = 'https://api.voyageai.com/v1',
+            timeout = DEFAULT_TIMEOUT,
+            retries = DEFAULT_MAX_RETRIES
+        )
+        self._api_key = api_key
+        self._model = model
+
+    def embeddings(self, input: str | list, options: dict = None):
+        response = self.post(
+            '/embeddings',
+            data = { 
+                "model": self._model, 
+                "input": input, 
+                "input_type": options['type'] if (options is not None) and ('type' in options) else None
+            },
+            headers = {
+                'Authorization': 'Bearer ' + self._api_key,
+                'Content-Type': 'application/json'
+            }
+        )
+
+        return json.loads(response.decode('utf-8'))['data'][0]['embedding'] if response is not None else None

yait_aichain-0.1/yait-aichain/_constants.py

@@ -0,0 +1,11 @@
+import urllib3
+
+# client default timeout is 10 minutes
+DEFAULT_TIMEOUT = urllib3.Timeout(connect=10.0, read=600.0)
+DEFAULT_MAX_RETRIES = urllib3.Retry(3, redirect=2)
+INITIAL_RETRY_DELAY = 1.0
+MAX_RETRY_DELAY = 8.0
+
+# models constants
+DEFAULT_CHATMODEL_TEMPERATURE = 0.75
+DEFAULT_MAX_TOKENS = 4096

yait_aichain-0.1/yait-aichain/_role.py

@@ -0,0 +1,271 @@
+from _client import BaseClient, YandexClient, OpenAIClient, StabilityAIClient, AnthropicClient, GoogleAIClient, MistralAIClient
+from copy import deepcopy
+import base64
+import mimetypes
+
+class Role:
+    name: str
+    description: str
+    model: str
+    instructions: dict
+    options: dict
+    api_key: str
+    variables: list
+
+    def __new__(cls, name: str, description: str, modelname: str, instructions:list):
+        match modelname:            
+            case "yandexgpt" | "yandexgpt-lite" | "summarization" as model:
+                instance = Role_YandexGPT
+            case "gpt-3.5-turbo" | "gpt-4" | "gpt-4-turbo" | "dall-e-3" | "gpt-4o" | "gpt-4o-mini" as model:
+                instance = Role_OpenAI
+            case "core" | "sd3" | "sd3-turbo":
+                instance = Role_StabilityAI
+            case "claude-3-opus-20240229" | "claude-3-sonnet-20240229" | "claude-3-haiku-20240307" | "claude-3-5-sonnet-20240620" as model:
+                instance = Role_AnthropicAI
+            case "gemini-pro" | "gemini-pro-vision" as model:
+                instance = Role_GoogleAI
+            case "mistral-large-latest" | "mistral-medium-latest" | "mistral-small-latest" as model:
+                instance = Role_MistralAI                   
+            case _:
+                instance = cls
+        return super().__new__(instance)
+        
+    def __init__(self, name: str, description: str, modelname: str, instructions:list ) -> None:
+        self.model = modelname
+        self.instructions = deepcopy(instructions)
+        self.name = name
+        self.description = description
+        self.variables = []
+
+        for instruction in self.instructions:
+            self.variables = self.variables + self.__getVariables(instruction['content'])
+
+    def __getVariables(self, content:str|list) -> list:
+        variables = []        
+        if isinstance(content, list):
+            for item in content:
+                if isinstance(item, dict) and 'text' in item:
+                    for variable in item['text'].split():
+                        if '{' in variable and '}' in variable:
+                            variable_name = variable.strip('{},.?!')
+                            variables.append(variable_name)
+        else:
+            for variable in content.split():
+                if '{' in variable and '}' in variable:
+                    variable_name = variable.strip('{},.?!')
+                    variables.append(variable_name)        
+
+        return variables
+
+    def castInstructions(self, options: dict):
+        for instruction in self.instructions:
+            if isinstance(instruction["content"], list) and instruction["role"] == "user":
+                updated = instruction.pop('content')
+                for item in updated:                   
+                    for key in item.keys():
+                        item[key] = self.__setVariables(item[key], options)
+                instruction['content'] = updated
+            else:
+                updated = self.__setVariables(instruction.pop('content'), options)
+                instruction['content'] = updated
+
+    def __setVariables(self, input_string, variables):
+        for key in variables:
+            input_string = input_string.replace("{" + key + "}", str(variables[key]))
+        return input_string
+
+    def run(self, api_key = None, options = None):
+        print("Running Role")
+
+class Role_OpenAI(Role):
+    def visionInstructions(self, instruction:list):
+        for item in instruction:
+            if "text" in item: item["type"] = "text"
+            if "image" in item: 
+
+                item["type"] = "image_url"
+                source = item.pop('image')
+
+                if 'data' in source and 'media_type' in source:
+                    item["image_url"] = {"url":f"data:{source['media_type']};base64,{source['data']}"}
+                elif 'file' in source:                    
+                    try:
+                        mimetypes.init()
+                        with open(source['file'], "rb") as image_file:                    
+                            image_data = base64.b64encode(image_file.read()).decode('utf-8')
+                            image_media_type = mimetypes.guess_type(source['file'])[0]
+                            item["image_url"] = {"url":f"data:{image_media_type};base64,{image_data}"}
+
+                    except Exception as e:
+                        print("An error occurred:", str(e))
+                        return None
+                    
+                elif 'url' in source:
+                    item["image_url"] = {"url":source['url']}
+                else:
+                    print(f"An error occurred: Unknown source type for image, file, data or url expected.")
+                    return None
+
+    def run(self, api_key: str,  options: dict = None):    
+        #Apply variables to instructions
+        if options: self.castInstructions(options)
+
+        match self.model:
+            case "gpt-3.5-turbo"as model:                
+                openaiChatCompletion = OpenAIClient(api_key = api_key, model = self.model).completion(messages = self.instructions)
+                return openaiChatCompletion['choices'][0]['message']['content'] if openaiChatCompletion is not None else None
+
+            case "gpt-4" | "gpt-4-turbo" | "gpt-4o" | "gpt-4o-mini" as model: #Extend instructions for Vision models
+                for instruction in self.instructions:
+                    if isinstance(instruction["content"], list) and instruction["role"] == "user":
+                        self.visionInstructions(instruction["content"]);
+               
+                openaiChatCompletion = OpenAIClient(api_key = api_key, model = self.model).completion(messages = self.instructions)
+                return openaiChatCompletion['choices'][0]['message']['content'] if openaiChatCompletion is not None else None
+                     
+            case "dall-e-3":
+                openaiImageGeneration = OpenAIClient(api_key = api_key, model = self.model).generation(messages = self.instructions, options = {"response_format" : "b64_json"})
+                return openaiImageGeneration if openaiImageGeneration is not None else None
+            case _:
+                return None
+
+class Role_MistralAI(Role):
+    def run(self, api_key: str, options: dict = None):
+
+        for instruction in self.instructions: #Extend instructions for Vision models
+            if isinstance(instruction["content"], list) and instruction["role"] == "user":
+                print("An error occurred: this model doesn't support vision functions")
+                return None
+
+        #Apply variables to instructions
+        if options: self.castInstructions(options)
+
+        mistralChatCompletion = MistralAIClient(api_key = api_key, model = self.model).completion(messages = self.instructions)
+        return mistralChatCompletion['choices'][0]['message']['content'] if mistralChatCompletion is not None else None
+
+class Role_AnthropicAI(Role):
+    def visionInstructions(self, instruction:list):
+        for item in instruction:
+            if "text" in item: item["type"] = "text"
+            if "image" in item:
+
+                source = item.pop('image')
+                item["type"] = "image"
+
+                if 'data' in source and 'media_type' in source:
+                    item["source"] = {
+                        "type": "base64",
+                        "media_type": source['media_type'],
+                        "data": source['data']
+                    }
+                elif 'file' in source:                    
+                    try:
+                        mimetypes.init()
+                        with open(source['file'], "rb") as image_file:                    
+                            image_data = base64.b64encode(image_file.read()).decode('utf-8')
+                            image_media_type = mimetypes.guess_type(source['file'])[0]
+                            
+                            item["source"] = {
+                                "data":image_data,
+                                "type": "base64",
+                                "media_type": image_media_type
+                            }
+
+                    except Exception as e:
+                        print("An error occurred:", str(e))
+                        return None
+                    
+                elif 'url' in source:
+                    image_client = BaseClient(source['url'])
+                    image = image_client.download()
+
+                    if image is not None:
+                        item["source"] = {
+                            "data": base64.b64encode(image['data']).decode('utf-8'),
+                            "media_type": image['media_type'],
+                            "type": "base64",
+                        }
+
+                else:
+                    print(f"An error occurred: Unknown source type for image, file, data or url expected.")
+                    return None              
+
+    def run(self, api_key: str, options: dict = None):
+        #Apply variables to instructions
+        if options: self.castInstructions(options)
+
+        #Extend instructions for Vision models
+        for instruction in self.instructions:
+            if isinstance(instruction["content"], list) and instruction["role"] == "user":
+                self.visionInstructions(instruction["content"]);
+    
+        AnthropicAICompletion = AnthropicClient(api_key = api_key, model = self.model).completion(messages = self.instructions)
+        return AnthropicAICompletion['content'][0]['text'] if AnthropicAICompletion is not None else None
+
+class Role_GoogleAI(Role):
+
+    def visionInstructions(self, instruction:list):
+        for item in instruction:
+            if "image" in item:
+                source = item.pop('image')
+                if 'data' in source and 'media_type' in source:
+                    item["inline_data"] = {
+                        "mime_type": source['media_type'],
+                        "data": source['data']
+                    }
+                elif 'file' in source:                    
+                    try:
+                        mimetypes.init()
+                        with open(source['file'], "rb") as image_file:                    
+                            image_data = base64.b64encode(image_file.read()).decode('utf-8')
+                            image_media_type = mimetypes.guess_type(source['file'])[0]
+                            
+                            item["inline_data"] = {
+                                "data":image_data,
+                                "mime_type": image_media_type
+                            }
+
+                    except Exception as e:
+                        print("An error occurred:", str(e))
+                        return None                    
+                elif 'url' in source:
+                    image_client = BaseClient(source['url'])
+                    image = image_client.download()
+
+                    if image is not None:
+                        item["inline_data"] = {
+                            "data": base64.b64encode(image['data']).decode('utf-8'),
+                            "mime_type": image['media_type']
+                        }
+                else:
+                    print(f"An error occurred: Unknown source type for image, file, data or url expected.")
+                    return None 
+                
+    def run(self, api_key: str, options: dict = None):
+        #Apply variables to instructions
+        if options: self.castInstructions(options)
+
+        #Extend instructions for Vision models
+        for instruction in self.instructions:
+            if isinstance(instruction["content"], list) and instruction["role"] == "user":
+                self.visionInstructions(instruction["content"]);
+
+        GoogleAICompletion = GoogleAIClient(api_key = api_key, model = self.model).completion(messages = self.instructions)
+        return GoogleAICompletion['candidates'][0]['content']['parts'][0]['text'] if GoogleAICompletion is not None else None
+
+class Role_YandexGPT(Role):
+    def run(self, api_key: str, options: dict):
+        if options is None or 'YaFolderID' not in options: 
+            print(f"An error occurred: You must provide a YaFolderID in the options for ant Yandex model.")
+            return None
+        if options: self.castInstructions(options)
+        
+        yandexChatCompletion = YandexClient(api_key = api_key, catalogId = options['YaFolderID'], model = self.model).completion(messages = self.instructions)
+        return yandexChatCompletion['result']['alternatives'][0]['message']['text'] if yandexChatCompletion is not None else None
+
+class Role_StabilityAI(Role):
+    def run(self, api_key: str, options: dict):
+        if options: self.castInstructions(options)
+        
+        stabilityaiImageGeneration = StabilityAIClient(api_key = api_key, model = self.model).generation(messages = self.instructions)
+        return stabilityaiImageGeneration if stabilityaiImageGeneration is not None else None

yait_aichain-0.1/yait_aichain.egg-info/PKG-INFO

@@ -0,0 +1,5 @@
+Metadata-Version: 2.1
+Name: yait-aichain
+Version: 0.1
+Summary: A simple Python library designed to wrap and unify AI functions from various popular services
+Author: YAIT

yait_aichain-0.1/yait_aichain.egg-info/SOURCES.txt

@@ -0,0 +1,9 @@
+setup.py
+yait-aichain/__init__.py
+yait-aichain/_client.py
+yait-aichain/_constants.py
+yait-aichain/_role.py
+yait_aichain.egg-info/PKG-INFO
+yait_aichain.egg-info/SOURCES.txt
+yait_aichain.egg-info/dependency_links.txt
+yait_aichain.egg-info/top_level.txt

yait_aichain-0.1/yait_aichain.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

yait_aichain-0.1/yait_aichain.egg-info/top_level.txt

@@ -0,0 +1 @@
+yait-aichain