lionagi 0.4.0__py3-none-any.whl → 0.5.1__py3-none-any.whl

lionagi/integrations/provider/__init__.py

@@ -1,11 +0,0 @@
-from ...libs.ln_api import APIUtil
-from .services import Services
-
-__all__ = [
-    "BaseService",
-    "BaseRateLimiter",
-    "StatusTracker",
-    "PayloadPackage",
-    "APIUtil",
-    "Services",
-]

lionagi/integrations/provider/_mapping.py

@@ -1,47 +0,0 @@
-from lionagi.integrations.config.oai_configs import oai_schema
-from lionagi.integrations.config.openrouter_configs import openrouter_schema
-
-from .litellm import LiteLLMService
-from .mlx_service import MLXService
-from .oai import OpenAIService
-from .ollama import OllamaService
-from .openrouter import OpenRouterService
-from .transformers import TransformersService
-
-SERVICE_PROVIDERS_MAPPING = {
-    "openai": {
-        "service": OpenAIService,
-        "schema": oai_schema,
-        "default_model": "gpt-3.5-turbo",
-    },
-    "openrouter": {
-        "service": OpenRouterService,
-        "schema": openrouter_schema,
-        "default_model": "gpt-3.5-turbo",
-    },
-    "litellm": {
-        "service": LiteLLMService,
-        "schema": oai_schema,
-        "default_model": "gpt-3.5-turbo",
-    },
-    "ollama": {
-        "service": OllamaService,
-        "schema": {"model": "llama3"},
-        "default_model": "llama3",
-    },
-    "transformers": {
-        "service": TransformersService,
-        "schema": {"model": "gpt2"},
-        "default_model": "gpt2",
-    },
-    "mlx": {
-        "service": MLXService,
-        "schema": {"model": "mlx-community/OLMo-7B-hf-4bit-mlx"},
-        "default_model": "mlx-community/OLMo-7B-hf-4bit-mlx",
-    },
-}
-
-# TODO
-# "Ollama": OllamaService,
-# "Transformers": TransformersService,
-# "MLX": MLXService,

lionagi/integrations/provider/litellm.py

@@ -1,53 +0,0 @@
-from lionagi.libs.ln_api import BaseService
-
-allowed_kwargs = [
-    "model",
-    "frequency_penalty",
-    "max_tokens",
-    "n",
-    "presence_penalty",
-    "response_format",
-    "seed",
-    "stop",
-    "stream",
-    "temperature",
-    "top_p",
-    "tools",
-    "tool_choice",
-    "user",
-]
-
-
-class LiteLLMService(BaseService):
-    def __init__(self, model: str = None, **kwargs):
-        super().__init__()
-
-        from lionagi.libs.sys_util import SysUtil
-
-        SysUtil.check_import("litellm")
-
-        import litellm
-
-        litellm.drop_params = True
-
-        self.acompletion = litellm.acompletion
-        self.model = model
-        self.kwargs = kwargs
-        self.allowed_kwargs = allowed_kwargs
-
-    async def serve_chat(self, messages, **kwargs):
-        payload = {"messages": messages}
-        config = {}
-        for k, v in kwargs.items():
-            if k in self.allowed_kwargs:
-                config[k] = v
-
-        kwargs = {**self.kwargs, **config}
-        kwargs["model"] = self.model or kwargs.get("model")
-
-        try:
-            completion = await self.acompletion(messages=messages, **kwargs)
-            return payload, completion.model_dump()
-        except Exception as e:
-            self.status_tracker.num_tasks_failed += 1
-            raise e

lionagi/integrations/provider/mistralai.py

@@ -1 +0,0 @@
-# ToDo

lionagi/integrations/provider/mlx_service.py

@@ -1,55 +0,0 @@
-import re
-
-import lionagi.libs.ln_convert as convert
-from lionagi.integrations.config.mlx_configs import model
-from lionagi.libs.ln_api import BaseService
-from lionagi.libs.sys_util import SysUtil
-
-
-class MLXService(BaseService):
-    def __init__(self, model=model, **kwargs):
-
-        SysUtil.check_import("mlx_lm")
-        SysUtil.check_import("ipywidgets")
-
-        if model is not None and "olmo" in str(model).lower():
-            SysUtil.check_import("olmo", pip_name="ai2-olmo")
-
-        from mlx_lm import generate, load
-
-        super().__init__()
-
-        model_, tokenizer = load(model, **kwargs)
-
-        self.model_name = model
-        self.model = model_
-        self.tokenizer = tokenizer
-        self.generate = generate
-        self.allowed_kwargs = []
-
-    async def serve_chat(self, messages, **kwargs):
-        if "verbose" not in kwargs.keys():
-            verbose = False
-
-        prompts = [msg["content"] for msg in messages if msg["role"] == "user"]
-
-        payload = {"messages": messages}
-
-        try:
-            response = self.generate(
-                self.model,
-                self.tokenizer,
-                prompt=f"{prompts[-1]} \nOutput: ",
-                verbose=verbose,
-            )
-            if "```" in response:
-                regex = re.compile(r"```[\s\S]*?```")
-                matches = regex.findall(response)
-                msg = matches[0].strip("```")
-                completion = {"choices": [{"message": {"content": msg}}]}
-            else:
-                completion = {"choices": [{"message": {"content": response}}]}
-            return payload, completion
-        except Exception as e:
-            self.status_tracker.num_tasks_failed += 1
-            raise e

lionagi/integrations/provider/oai.py

@@ -1,196 +0,0 @@
-from os import getenv
-
-from lionagi.integrations.config.oai_configs import oai_schema
-from lionagi.libs.ln_api import BaseService, PayloadPackage
-
-allowed_kwargs = [
-    "model",
-    "frequency_penalty",
-    "n",
-    "presence_penalty",
-    "response_format",
-    "temperature",
-    "top_p",
-    "seed",
-    "stop",
-    "stream",
-    "stream_options",
-    "tools",
-    "tool_choice",
-    "user",
-    "max_tokens",
-    "logprobs",
-    "top_logprobs",
-    "logit_bias",
-]
-
-
-class OpenAIService(BaseService):
-    """
-    A service to interact with OpenAI's API endpoints.
-
-    Attributes:
-            base_url (str): The base URL for the OpenAI 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 OpenAI 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"))
-    """
-
-    base_url = "https://api.openai.com/v1/"
-    available_endpoints = [
-        "chat/completions",
-        "finetune",
-        "audio_speech",
-        "audio_transcriptions",
-        "audio_translations",
-        "embeddings",
-    ]
-    schema = oai_schema
-    key_scheme = "OPENAI_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 = []
-        self.allowed_kwargs = allowed_kwargs
-
-    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 assistant_response from the API.
-
-        Raises:
-                ValueError: If the specified endpoint is not supported.
-
-        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
-        """
-        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, required_tokens=None, **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 assistant_response from the API.
-
-        Raises:
-                Exception: If the API call fails.
-        """
-        if "chat/completions" not in self.active_endpoint:
-            await self.init_endpoint("chat/completions")
-            self.active_endpoint.append("chat/completions")
-
-        msgs = []
-
-        for msg in messages:
-            if isinstance(msg, dict):
-                content = msg.get("content")
-                if isinstance(content, (dict, str)):
-                    msgs.append({"role": msg["role"], "content": content})
-                elif isinstance(content, list):
-                    _content = []
-                    for i in content:
-                        if "text" in i:
-                            _content.append(
-                                {"type": "text", "text": str(i["text"])}
-                            )
-                        elif "image_url" in i:
-                            _content.append(
-                                {
-                                    "type": "image_url",
-                                    "image_url": {
-                                        "url": f"{i['image_url'].get('url')}",
-                                        "detail": i["image_url"].get(
-                                            "detail", "low"
-                                        ),
-                                    },
-                                }
-                            )
-                    msgs.append({"role": msg["role"], "content": _content})
-
-        payload = PayloadPackage.chat_completion(
-            msgs,
-            self.endpoints["chat/completions"].config,
-            self.schema["chat/completions"],
-            **kwargs,
-        )
-        try:
-            completion = await self.call_api(
-                payload,
-                "chat/completions",
-                "post",
-                required_tokens=required_tokens,
-            )
-            return payload, completion
-        except Exception as e:
-            self.status_tracker.num_tasks_failed += 1
-            raise e
-
-    async def serve_embedding(self, embed_str, required_tokens=None, **kwargs):
-        if "embeddings" not in self.active_endpoint:
-            await self.init_endpoint("embeddings")
-            self.active_endpoint.append("embeddings")
-
-        payload = PayloadPackage.embeddings(
-            embed_str,
-            self.endpoints["embeddings"].config,
-            self.schema["embeddings"],
-            **kwargs,
-        )
-
-        try:
-            embed = await self.call_api(
-                payload, "embeddings", "post", required_tokens=required_tokens
-            )
-            return payload, embed
-        except Exception as e:
-            self.status_tracker.num_tasks_failed += 1
-            raise e

lionagi/integrations/provider/ollama.py

@@ -1,55 +0,0 @@
-from lionagi.integrations.config.ollama_configs import model
-from lionagi.libs.ln_api import BaseService
-
-allowed_kwargs = [
-    "model",
-    "frequency_penalty",
-    # "max_tokens",
-    "n",
-    "presence_penalty",
-    "response_format",
-    "seed",
-    "stop",
-    "stream",
-    # "temperature",
-    "top_p",
-    "tools",
-    "tool_choice",
-    "user",
-]
-
-
-class OllamaService(BaseService):
-
-    def __init__(self, model: str = model, **kwargs):
-        super().__init__()
-
-        from lionagi.libs.sys_util import SysUtil
-
-        SysUtil.check_import("ollama")
-
-        import ollama
-
-        self.ollama = ollama
-        self.model = model
-        self.client = self.ollama.AsyncClient()
-        self.allowed_kwargs = allowed_kwargs
-
-    async def serve_chat(self, messages, **kwargs):
-        config = {}
-        for k, v in kwargs.items():
-            if k in allowed_kwargs:
-                config[k] = v
-
-        self.ollama.pull(self.model)
-        payload = {"messages": messages}
-        if "model" not in config:
-            config["model"] = self.model
-
-        try:
-            completion = await self.client.chat(messages=messages, **config)
-            completion["choices"] = [{"message": completion.pop("message")}]
-            return payload, completion
-        except Exception as e:
-            self.status_tracker.num_tasks_failed += 1
-            raise e

lionagi/integrations/provider/openrouter.py

@@ -1,170 +0,0 @@
-from os import getenv
-
-from lionagi.integrations.config.openrouter_configs import openrouter_schema
-from lionagi.libs.ln_api import BaseService, PayloadPackage
-
-allowed_kwargs = [
-    "model",
-    "frequency_penalty",
-    "n",
-    "presence_penalty",
-    "response_format",
-    "temperature",
-    "top_p",
-    "seed",
-    "stop",
-    "stream",
-    "stream_options",
-    "tools",
-    "tool_choice",
-    "user",
-    "max_tokens",
-    "logprobs",
-    "top_logprobs",
-    "logit_bias",
-]
-
-
-class OpenRouterService(BaseService):
-    base_url = "https://openrouter.ai/api/v1/"
-    available_endpoints = ["chat/completions"]
-    schema = openrouter_schema
-    key_scheme = "OPENROUTER_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 = []
-        self.allowed_kwargs = allowed_kwargs
-
-    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 assistant_response from the API.
-
-        Raises:
-                ValueError: If the specified endpoint is not supported.
-
-        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
-        """
-        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, required_tokens=None, **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 assistant_response from the API.
-
-        Raises:
-                Exception: If the API call fails.
-        """
-        if "chat/completions" not in self.active_endpoint:
-            await self.init_endpoint("chat/completions")
-            self.active_endpoint.append("chat/completions")
-
-        msgs = []
-
-        for msg in messages:
-            if isinstance(msg, dict):
-                content = msg.get("content")
-                if isinstance(content, (dict, str)):
-                    msgs.append({"role": msg["role"], "content": content})
-                elif isinstance(content, list):
-                    _content = []
-                    for i in content:
-                        if "text" in i:
-                            _content.append(
-                                {"type": "text", "text": str(i["text"])}
-                            )
-                        elif "image_url" in i:
-                            _content.append(
-                                {
-                                    "type": "image_url",
-                                    "image_url": {
-                                        "url": f"{i['image_url'].get('url')}",
-                                        "detail": i["image_url"].get(
-                                            "detail", "low"
-                                        ),
-                                    },
-                                }
-                            )
-                    msgs.append({"role": msg["role"], "content": _content})
-
-        payload = PayloadPackage.chat_completion(
-            msgs,
-            self.endpoints["chat/completions"].config,
-            self.schema["chat/completions"],
-            **kwargs,
-        )
-        try:
-            completion = await self.call_api(
-                payload,
-                "chat/completions",
-                "post",
-                required_tokens=required_tokens,
-            )
-            return payload, completion
-        except Exception as e:
-            self.status_tracker.num_tasks_failed += 1
-            raise e
-
-    # async def serve_embedding(self, embed_str, required_tokens=None, **kwargs):
-    #     if "embeddings" not in self.active_endpoint:
-    #         await self.init_endpoint("embeddings")
-    #         self.active_endpoint.append("embeddings")
-
-    #     payload = PayloadPackage.embeddings(
-    #         embed_str,
-    #         self.endpoints["embeddings"].config,
-    #         self.schema["embeddings"],
-    #         **kwargs,
-    #     )
-
-    #     try:
-    #         embed = await self.call_api(
-    #             payload, "embeddings", "post", required_tokens=required_tokens
-    #         )
-    #         return payload, embed
-    #     except Exception as e:
-    #         self.status_tracker.num_tasks_failed += 1
-    #         raise e