lionagi 0.0.201__py3-none-any.whl → 0.0.204__py3-none-any.whl

lionagi/_services/anthropic.py

@@ -1 +1,79 @@
-# TODO
+from os import getenv
+from .base_service import BaseService, PayloadCreation
+
+class AnthropicService(BaseService):
+    """
+    A service to interact with Anthropic's API endpoints.
+
+    Attributes:
+        base_url (str): The base URL for the Anthropic API.
+        available_endpoints (list): A list of available API endpoints.
+        schema (dict): The schema configuration for the API.
+        key_scheme (str): The environment variable name for Anthropic API key.
+        token_encoding_name (str): The default token encoding scheme.
+
+    Examples:
+        >>> service = AnthropicService(api_key="your_api_key")
+        >>> asyncio.run(service.serve("Hello, world!", "chat/completions"))
+        (payload, completion)
+    """
+
+    base_url = "https://api.anthropic.com/v1/"
+    available_endpoints = ['chat/completions']
+    schema = {}        # TODO
+    key_scheme = "ANTHROPIC_API_KEY"
+    token_encoding_name = "cl100k_base"
+
+    def __init__(self, api_key = None, key_scheme = None,schema = None, token_encoding_name: str = "cl100k_base", **kwargs):
+        key_scheme = key_scheme or self.key_scheme            
+        super().__init__(
+            api_key = api_key or getenv(key_scheme),
+            schema = schema or self.schema,
+            token_encoding_name=token_encoding_name, 
+            **kwargs
+        )
+        self.active_endpoint = []
+
+    async def serve(self, input_, endpoint="chat/completions", method="post", **kwargs):
+        """
+        Serves the input using the specified endpoint and method.
+
+        Args:
+            input_: The input text to be processed.
+            endpoint: The API endpoint to use for processing.
+            method: The HTTP method to use for the request.
+            **kwargs: Additional keyword arguments to pass to the payload creation.
+
+        Returns:
+            A tuple containing the payload and the completion response from the API.
+        """
+        if endpoint not in self.active_endpoint:
+            await self. init_endpoint(endpoint)
+        if endpoint == "chat/completions":
+            return await self.serve_chat(input_, **kwargs)
+        else:
+            return ValueError(f'{endpoint} is currently not supported')
+    
+    async def serve_chat(self, messages, **kwargs):
+        """
+        Serves the chat completion request with the given messages.
+
+        Args:
+            messages: The messages to be included in the chat completion.
+            **kwargs: Additional keyword arguments for payload creation.
+
+        Returns:
+            A tuple containing the payload and the completion response from the API.
+        """
+        if "chat/completions" not in self.active_endpoint:
+            await self. init_endpoint("chat/completions")
+            self.active_endpoint.append("chat/completions")
+        payload = PayloadCreation.chat_completion(
+            messages, self.endpoints["chat/completions"].config, self.schema["chat/completions"], **kwargs)
+
+        try:
+            completion = await self.call_api(payload, "chat/completions", "post")
+            return payload, completion
+        except Exception as e:
+            self.status_tracker.num_tasks_failed += 1
+            raise e

lionagi/_services/base_service.py

@@ -283,6 +283,7 @@ class BaseService:
             'interval': interval
         }
 
+
     async def init_endpoint(self, endpoint_: Optional[Union[List[str], List[EndPoint], str, EndPoint]] = None) -> None:
         """
         Initializes the specified endpoint or all endpoints if none is specified.
@@ -411,4 +412,3 @@ class PayloadCreation:
             optional_=schema['optional'],
             input_key="training_file", 
             **kwargs)
-        

lionagi/_services/services.py

@@ -1,11 +1,9 @@
-from .oai import OpenAIService
-from .openrouter import OpenRouterService
-
 class Services:
     
     @staticmethod
     def OpenAI(**kwargs):
-        """A service to interact with OpenAI's API endpoints.
+        """
+        A service to interact with OpenAI's API endpoints.
 
         Attributes:
             api_key (Optional[str]): The API key used for authentication.
@@ -13,25 +11,19 @@ class Services:
             status_tracker (StatusTracker): The object tracking the status of API calls.
             endpoints (Dict[str, EndPoint]): A dictionary of endpoint objects.
             base_url (str): The base URL for the OpenAI API.
-            available_endpoints (list): A list of available API endpoints.
-                ['chat/completions', 'finetune', 'audio_speech', 'audio_transcriptions', 'audio_translations']
+            available_endpoints (list): A list of available API endpoints, including 
+                'chat/completions'
             key_scheme (str): The environment variable name for API key.
             token_encoding_name (str): The default token encoding scheme.
-
-        Examples:
-            >>> service = OpenAIService(api_key="your_api_key")
-            >>> asyncio.run(service.serve("Hello, world!", "chat/completions"))
-            (payload, completion)
-
-            >>> service = OpenAIService()
-            >>> asyncio.run(service.serve("Convert this text to speech.", "audio_speech"))
-            ValueError: 'audio_speech' is currently not supported
         """
+
+        from .oai import OpenAIService
         return OpenAIService(**kwargs)
     
     @staticmethod 
     def OpenRouter(**kwargs):
-        """A service to interact with OpenRouter's API endpoints.
+        """
+        A service to interact with OpenRouter's API endpoints.
 
         Attributes:
             api_key (Optional[str]): The API key used for authentication.
@@ -39,17 +31,61 @@ class Services:
             status_tracker (StatusTracker): The object tracking the status of API calls.
             endpoints (Dict[str, EndPoint]): A dictionary of endpoint objects.
             base_url (str): The base URL for the OpenAI API.
-            available_endpoints (list): A list of available API endpoints. ['chat/completions']
+            available_endpoints (list): A list of available API endpoints, including 
+                'chat/completions'
             key_scheme (str): The environment variable name for API key.
             token_encoding_name (str): The default token encoding scheme.
+        """
 
-        Examples:
-            >>> service = OpenAIService(api_key="your_api_key")
-            >>> asyncio.run(service.serve("Hello, world!", "chat/completions"))
-            (payload, completion)
+        from .openrouter import OpenRouterService
+        return OpenRouterService(**kwargs)
 
-            >>> service = OpenAIService()
-            >>> asyncio.run(service.serve("Convert this text to speech.", "audio_speech"))
-            ValueError: 'audio_speech' is currently not supported
+    @staticmethod
+    def Transformers(**kwargs):
         """
-        return OpenRouterService(**kwargs)
+        A service to interact with Transformers' pipeline
+
+        Attributes:
+            task (str): The specific task to be performed by the transformer model. 
+                Currently, only 'conversational' tasks are supported.
+            model (Union[str, Any]): Identifier for the transformer model to be used. This 
+                can be a model name or a path to a model.
+            config (Union[str, Dict, Any]): Configuration for the transformer model. Can 
+                include tokenizer information among others.
+            pipe (pipeline): The loaded transformer pipeline for the specified task, model, 
+                and configuration.
+
+        Warnings:
+            - Ensure the selected model is suitable for conversational tasks to avoid 
+            unexpected behavior.
+            - As this service heavily relies on external libraries (Hugging Face's 
+            Transformers), ensure they are installed and updated to compatible versions.
+
+        Dependencies:
+            - Requires the `transformers` library by Hugging Face and `asyncio` for 
+            asynchronous operations.
+        """
+
+        from .transformers import TransformersService
+        return TransformersService(**kwargs)
+
+
+    @staticmethod
+    def Anthropic(**kwargs):
+        """
+        A service to interact with Anthropic's API endpoints.
+
+        Attributes:
+            api_key (Optional[str]): The API key used for authentication.
+            schema (Dict[str, Any]): The schema defining the service's endpoints.
+            status_tracker (StatusTracker): The object tracking the status of API calls.
+            endpoints (Dict[str, EndPoint]): A dictionary of endpoint objects.
+            base_url (str): The base URL for the Anthropic API.
+            available_endpoints (list): A list of available API endpoints, including 
+                'chat/completions'
+            key_scheme (str): The environment variable name for API key.
+            token_encoding_name (str): The default token encoding scheme.
+        """
+
+        from .anthropic import AnthropicService
+        return AnthropicService(**kwargs)

lionagi/_services/transformers.py

@@ -0,0 +1,46 @@
+from typing import Union, str, Dict, Any
+from transformers import pipeline, Conversation
+
+from .base_service import BaseService
+
+import functools
+from concurrent.futures import ThreadPoolExecutor
+import asyncio
+
+
+def force_async(fn):
+    pool = ThreadPoolExecutor()
+
+    @functools.wraps(fn)
+    def wrapper(*args, **kwargs):
+        future = pool.submit(fn, *args, **kwargs)
+        return asyncio.wrap_future(future)  # make it awaitable
+
+    return wrapper
+
+
+class TransformersService(BaseService):
+    def __init__(self, task: str = None, model: Union[str, Any] = None, config: Union[str, Dict, Any] = None, **kwargs):
+        super().__init__()
+        self.task = task
+        self.model = model
+        self.config = config
+        self.pipe = pipeline(task=task, model=model, config=config, **kwargs)
+
+    @force_async
+    def serve_chat(self, messages, **kwargs):
+        if self.task:
+            if self.task != 'conversational':
+                raise ValueError(f"Invalid transformers pipeline task: {self.task}. Valid task: 'conversational'")
+
+        payload = {'messages': messages}
+        conversation = self.pipe(Conversation(messages), **kwargs)
+        completion = {"Conversation id": conversation.uuid,
+                      "model": self.pipe.model,
+                      "choices": [{
+                          "message": conversation.messages[-1]
+                      }]
+        }
+
+        return payload, completion
+

lionagi/configs/oai_configs.py

@@ -2,7 +2,7 @@
 
 # ChatCompletion
 oai_chat_llmconfig = {
-    "model": "gpt-4-1106-preview",
+    "model": "gpt-4-turbo-preview",
     "frequency_penalty": 0,
     "max_tokens": None,
     "n": 1,

lionagi/configs/openrouter_configs.py

@@ -1,5 +1,5 @@
 openrouter_chat_llmconfig = {
-    "model": "gpt-4-1106-preview",
+    "model": "gpt-4-turbo-preview",
     "frequency_penalty": 0,
     "max_tokens": None,
     "n": 1,

lionagi/core/__init__.py

@@ -1,15 +1,11 @@
-from .messages import System, Instruction
-from .instruction_set import InstructionSet
-from .conversation import Conversation
-from .branch import Branch
-from .sessions import Session
+from .messages.messages import System, Instruction
+from .branch.branch import Branch
+from .sessions.session import Session
 
 
 __all__  = [
     'System',
     'Instruction',
-    'Conversation',
-    'InstructionSet',
     'Branch',
     'Session'
 ]