lionagi 0.0.205__tar.gz → 0.0.206__tar.gz

{lionagi-0.0.205 → lionagi-0.0.206}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: lionagi
-Version: 0.0.205
+Version: 0.0.206
 Summary: Towards automated general intelligence.
 Author: HaiyangLi
 Author-email: Haiyang Li <ocean@lionagi.ai>

lionagi-0.0.206/lionagi/_services/litellm.py

@@ -0,0 +1,33 @@
+from ..utils.sys_util import install_import, is_package_installed
+from .base_service import BaseService
+
+
+class LiteLLMService(BaseService):
+    def __init__(self, model: str = None, **kwargs):
+        super().__init__()
+
+        try: 
+            if not is_package_installed('litellm'):
+                install_import(
+                    package_name='litellm',
+                    import_name='acompletion'
+                )
+            from litellm import acompletion 
+            self.acompletion = acompletion
+        except:
+            raise ImportError(f'Unable to import required module from ollama. Please make sure that ollama is installed.')
+        
+        self.model = model
+        self.kwargs = kwargs
+
+    async def serve_chat(self, messages, **kwargs):
+        payload = {'messages': messages}
+        kwargs = {**self.kwargs, **kwargs}
+
+        try:
+            completion = await self.acompletion(model=self.model, messages=messages, **kwargs)
+            return payload, completion
+        except Exception as e:
+            self.status_tracker.num_tasks_failed += 1
+            raise e
+        

lionagi-0.0.206/lionagi/_services/mlx_service.py

@@ -0,0 +1,39 @@
+from ..utils.sys_util import install_import, is_package_installed, as_dict
+from .base_service import BaseService
+
+
+class MlXService(BaseService):
+    def __init__(self, model="mlx-community/OLMo-7B-hf-4bit-mlx", **kwargs):
+        
+        if not is_package_installed('mlx_lm'):
+            install_import(package_name='mlx_lm')
+            
+        from mlx_lm import load, generate
+        super().__init__()
+        
+        model_, tokenizer = load(model, **kwargs)
+        
+        self.model_name = model
+        self.model = model_
+        self.tokenizer = tokenizer
+        self.generate = generate
+        
+    async def serve_chat(self, messages, **kwargs):
+        prompts = [as_dict(msg['content'])['instruction'] for msg in messages if msg['role'] == 'user']
+        
+        payload = {'messages': messages}
+        
+        try:
+            response = self.generate(
+                self.model, self.tokenizer, prompt=f"{prompts[-1]} \nOutput: ", **kwargs
+            )
+            completion = {
+                'model': self.model_name, 
+                'choices': [{'message': response}]
+            }
+            
+            return payload, completion
+        except Exception as e:
+            self.status_tracker.num_tasks_failed += 1
+            raise e
+        

lionagi-0.0.206/lionagi/_services/ollama.py

@@ -0,0 +1,33 @@
+from ..utils.sys_util import install_import, is_package_installed
+from .base_service import BaseService
+
+class OllamaService(BaseService):
+    def __init__(self, model: str = None, **kwargs):
+        super().__init__()
+        
+        try: 
+            if not is_package_installed('ollama'):
+                install_import(
+                    package_name='ollama',
+                    import_name='Client'
+                )
+            import ollama    
+            self.ollama = ollama
+        except:
+            raise ImportError(f'Unable to import required module from ollama. Please make sure that ollama is installed.')
+        
+        self.model = model
+        self.client = self.ollama.Client(**kwargs)
+
+    async def serve_chat(self, messages, **kwargs):
+        self.ollama.pull(self.model)
+        payload = {'messages': messages}
+
+        try:
+            completion = self.client.chat(model=self.model, messages=messages, **kwargs)
+            completion['choices'] = [{'message': completion.pop('message')}]
+            return payload, completion
+        except Exception as e:
+            self.status_tracker.num_tasks_failed += 1
+            raise e
+        

{lionagi-0.0.205 → lionagi-0.0.206}/lionagi/_services/services.py

@@ -89,3 +89,43 @@ class Services:
 
         from .anthropic import AnthropicService
         return AnthropicService(**kwargs)
+
+    @staticmethod
+    def Ollama(**kwargs):
+        """
+        A service to interact with Ollama
+        
+        Attributes:
+            model (str): name of the model to use
+            kwargs (Optional[Any]): additional kwargs for calling the model
+        """
+    
+        from .ollama import OllamaService
+        return OllamaService(**kwargs)
+
+    @staticmethod
+    def LiteLLM(**kwargs):
+        """
+        A service to interact with Litellm
+        
+        Attributes:
+            model (str): name of the model to use
+            kwargs (Optional[Any]): additional kwargs for calling the model
+        """
+        
+        from .litellm import LiteLLMService
+        return LiteLLMService(**kwargs)
+    
+    @staticmethod
+    def MLX(**kwargs):
+        """
+        A service to interact with MlX
+        
+        Attributes:
+            model (str): name of the model to use
+            kwargs (Optional[Any]): additional kwargs for calling the model
+        """
+        
+        from .mlx_service import MlXService
+        return MlXService(**kwargs)
+    

lionagi-0.0.206/lionagi/_services/transformers.py

@@ -0,0 +1,73 @@
+from typing import Union, Dict, Any
+import subprocess
+
+from ..utils.sys_util import install_import, get_cpu_architecture, is_package_installed
+from .base_service import BaseService
+
+
+def get_pytorch_install_command():
+    cpu_arch = get_cpu_architecture()
+
+    if cpu_arch == 'apple_silicon':
+        return "pip install --pre torch torchvision torchaudio --extra-index-url https://download.pytorch.org/whl/nightly/cpu"
+    else:
+        # Default CPU installation
+        return "pip install torch torchvision torchaudio"
+
+def install_pytorch():
+    command = get_pytorch_install_command()
+    try:
+        subprocess.run(command.split(), check=True)
+        print("PyTorch installed successfully.")
+    except subprocess.CalledProcessError as e:
+        print(f"Failed to install PyTorch: {e}")
+
+class TransformersService(BaseService):
+    def __init__(self, task: str = None, model: Union[str, Any] = None, config: Union[str, Dict, Any] = None, device='cpu', **kwargs):
+        super().__init__()
+        self.task = task
+        self.model = model
+        self.config = config
+        try:
+            from transformers import pipeline
+            self.pipeline = pipeline
+        except ImportError:
+            try: 
+                if not is_package_installed('torch'):
+                    in_ = input("PyTorch is required for transformers. Would you like to install it now? (y/n): ")
+                    if in_ == 'y':
+                        install_pytorch()
+                if not is_package_installed('transformers'):
+                    in_ = input("transformers is required. Would you like to install it now? (y/n): ")
+                    if in_ == 'y':
+                        install_import(
+                            package_name='transformers',
+                            import_name='pipeline'
+                        )
+                    from transformers import pipeline
+                    self.pipeline = pipeline
+            except Exception as e:
+                raise ImportError(f'Unable to import required module from transformers. Please make sure that transformers is installed. Error: {e}')
+        
+        self.pipe = self.pipeline(task=task, model=model, config=config, device=device, **kwargs)
+
+    async def serve_chat(self, messages, **kwargs):
+        if self.task:
+            if self.task != 'conversational':
+                raise ValueError(f"Invalid transformers pipeline task: {self.task}.")
+
+        payload = {'messages': messages}
+        conversation = self.pipe(str(messages), **kwargs)
+            
+        texts = conversation[-1]['generated_text']
+        msgs = str(texts.split(']')[1:]).replace('\\n', '').replace("[\'", "").replace('\\', '')
+        
+        completion = {
+                      "model": self.pipe.model,
+                      "choices": [{
+                          "message": msgs
+                      }]
+        }
+
+        return payload, completion
+    

{lionagi-0.0.205 → lionagi-0.0.206}/lionagi/bridge/langchain.py

@@ -1,5 +1,5 @@
 from typing import Union, Callable, List, Dict, Any, TypeVar
-from ..utils.sys_util import change_dict_key
+from ..utils.sys_util import change_dict_key, install_import
 from ..schema.data_node import DataNode
 
 
@@ -43,7 +43,18 @@ def to_langchain_document(datanode: T, **kwargs: Any) -> Any:
         >>> isinstance(lc_document, LangchainDocument)
         True
     """
-    from langchain.schema import Document
+    try:
+        from langchain.schema import Document
+    except ImportError:
+        try:
+            install_import(
+                package_name='langchain', 
+                module_name='schema', 
+                import_name='Document',
+            )
+            from langchain.schema import Document
+        except Exception as e:
+            raise ImportError(f'Unable to import required module from langchain. Please make sure that langchain is installed. Error: {e}')
 
     dnode = datanode.to_dict()
     change_dict_key(dnode, old_key='content', new_key='page_content')
@@ -73,11 +84,24 @@ def langchain_loader(loader: Union[str, Callable],
         >>> isinstance(data, dict)
         True
     """
-    import langchain.document_loaders as document_loaders
-
+    try:
+        import langchain.document_loaders as document_loaders
+    except ImportError:
+        try:
+            install_import(
+                package_name='langchain', 
+                module_name='document_loaders', 
+            )
+            import langchain.document_loaders as document_loaders
+        except Exception as e:
+            raise ImportError(f'Unable to import required module from langchain. Please make sure that langchain is installed. Error: {e}')
+        
     try:
         if isinstance(loader, str):
-            loader = getattr(document_loaders, loader)
+            try:
+                loader = getattr(document_loaders, loader)
+            except ImportError as e:
+                raise ValueError(f'Unable to import {loader} from langchain.document_loaders. Some dependency of LangChain are not installed. Error: {e}')
         else:
             loader = loader
     except Exception as e:
@@ -110,7 +134,17 @@ def langchain_text_splitter(data: Union[str, List],
         ValueError: If the specified text splitter is invalid or if the splitting fails.
     """
 
-    import langchain.text_splitter as text_splitter
+    try:
+        import langchain.text_splitter as text_splitter
+    except ImportError:
+        try:
+            install_import(
+                package_name='langchain', 
+                module_name='text_splitter'
+                )
+            import langchain.text_splitter as text_splitter
+        except Exception as e:
+            raise ImportError(f'Unable to import required module from langchain. Please make sure that langchain is installed. Error: {e}')
 
     try:
         if isinstance(splitter, str):

{lionagi-0.0.205 → lionagi-0.0.206}/lionagi/bridge/llama_index.py

@@ -1,5 +1,5 @@
 from typing import Union, Callable, List, Any, Dict, TypeVar
-from ..utils.sys_util import change_dict_key
+from ..utils.sys_util import change_dict_key, install_import, is_package_installed
 from ..schema.data_node import DataNode
 
 
@@ -38,7 +38,18 @@ def to_llama_index_textnode(datanode: T, **kwargs: Any) -> Any:
         datanode = DataNode(...)
         textnode = to_llama_index_textnode(datanode, additional_arg=1)
     """
-    from llama_index.schema import TextNode
+    try:
+        from llama_index.schema import TextNode
+    except ImportError:
+        try:
+            install_import(
+                package_name='llama_index', 
+                module_name='schema',
+                import_name='TextNode'
+            )
+            from llama_index.schema import TextNode
+        except Exception as e:
+            raise ImportError(f'Unable to import required module from llama_index. Please make sure that llama_index is installed. Error: {e}')
 
     dnode = datanode.to_dict()
     change_dict_key(dnode, old_key='content', new_key='text')
@@ -67,14 +78,36 @@ def get_llama_reader(reader: Union[str, Callable]) -> Callable:
         def custom_reader(): pass
         reader = get_llama_reader(custom_reader)
     """
+    
     try:
         if isinstance(reader, str):
             if reader == 'SimpleDirectoryReader':
-                from llama_index import SimpleDirectoryReader
-                return SimpleDirectoryReader
-            else:
-                from llama_index import download_loader
-                return download_loader(reader)
+                try:
+                    from llama_index import SimpleDirectoryReader
+                    return SimpleDirectoryReader
+                except ImportError or ModuleNotFoundError:
+                    try:
+                        install_import(
+                            package_name='llama_index',
+                            import_name='SimpleDirectoryReader'
+                        )
+                        from llama_index import SimpleDirectoryReader
+                        return SimpleDirectoryReader
+                    except Exception as e:
+                        raise ImportError(f'Failed to import SimpleDirectoryReader. Error: {e}')
+            else:                
+                try:
+                    from llama_index import download_loader
+                    return download_loader(reader)
+                except ImportError:
+                    try:
+                        install_import(
+                            package_name='llama_index',
+                            import_name='download_loader'
+                        )
+                        return download_loader(reader)
+                    except Exception as e:
+                        raise ImportError(f'Failed to import download_loader from LlamaIndex. Error: {e}')
         else:
             return reader
     except Exception as e:
@@ -133,11 +166,43 @@ def get_llama_parser(parser: Union[str, Callable]) -> Callable:
         def custom_parser(): pass
         parser = get_llama_parser(custom_parser)
     """
-    import llama_index.node_parser as node_parser
-    import llama_index.text_splitter as text_splitter
+    
+    try:
+        import llama_index.node_parser as node_parser
+    except ImportError:
+        try:
+            install_import(
+                package_name='llama_index',
+                module_name='node_parser'
+            )
+            import llama_index.node_parser as node_parser
+        except ImportError:
+            raise ImportError('Failed to import Llama Index. Please install Llama Index to use this function.')
+        except Exception as e:
+            raise ValueError(f'Invalid node parser: {parser}. Error: {e}')
 
     try:
-        return getattr(node_parser, parser)
+        import llama_index.text_splitter as text_splitter
+    except ImportError:
+        try:
+            install_import(
+                package_name='llama_index',
+                module_name='text_splitter'
+            )
+            import llama_index.text_splitter as text_splitter
+        except ImportError:
+            raise ImportError('Failed to import Llama Index. Please install Llama Index to use this function.')
+        
+    try:
+        if parser == 'CodeSplitter':
+            if not is_package_installed('tree_sitter_languages'):
+                install_import(package_name='tree_sitter_languages')
+                
+        a = getattr(node_parser, parser)
+        if a is not None:
+            return a
+        else:
+            raise ImportError(f'Failed to import {parser} from Llama Index.')
     except Exception as e1:
         try:
             if isinstance(parser, str):
@@ -172,13 +237,25 @@ def llama_index_node_parser(documents: List[Any],
     Example:
         nodes = llama_index_node_parser(documents, "DefaultNodeParser")
     """
-    parser = get_llama_parser(parser)
 
     try:
+        parser = get_llama_parser(parser)
         parser_obj = parser(*parser_args, **parser_kwargs)
         nodes = parser_obj.get_nodes_from_documents(documents, **parsing_kwargs)
         return nodes
 
+    except ImportError as e:
+        module_name = str(e).split("\'")[-2]
+        try:
+            install_import(package_name=module_name)
+            parser = get_llama_parser(parser)
+            parser_obj = parser(*parser_args, **parser_kwargs)
+            nodes = parser_obj.get_nodes_from_documents(documents, **parsing_kwargs)
+            return nodes
+        except Exception as e:
+            raise ImportError(f'Failed to install and import {module_name}. Error: {e}')
+            
+            
     except Exception as e1:
         try:
             parser_obj = parser.from_defaults(*parser_args, **parser_kwargs)

{lionagi-0.0.205 → lionagi-0.0.206}/lionagi/core/branch/branch.py

@@ -7,7 +7,7 @@ from collections import deque
 import asyncio
 from dotenv import load_dotenv
 
-from lionagi.utils import as_dict, get_flattened_keys, lcall
+from lionagi.utils import as_dict, get_flattened_keys, alcall, lcall, mcall, to_list
 from lionagi.schema import Tool
 from lionagi._services.base_service import StatusTracker, BaseService
 from lionagi._services.oai import OpenAIService
@@ -375,10 +375,10 @@ class Branch(Conversation):
                         self.tool_manager.get_function_call
                     )
                     
-                    # outs = await alcall(func_calls, self.tool_manager.invoke)
+                    outs = await alcall(func_calls, self.tool_manager.invoke)
+                    
+                    outs = to_list(outs, flatten=True)
 
-                    tasks = [self.tool_manager.invoke(i) for i in func_calls]
-                    outs = await asyncio.gather(*tasks)
                     for out_, f in zip(outs, func_calls):
                         self.add_message(
                             response={

{lionagi-0.0.205 → lionagi-0.0.206}/lionagi/core/sessions/session.py

@@ -8,9 +8,9 @@ from ..messages.messages import System, Instruction
 from ..branch.branch import Branch
 from ..branch.branch_manager import BranchManager
 
-            
+
 load_dotenv()
-OAIService = OpenAIService()
+
 
 class Session:
     """
@@ -33,7 +33,7 @@ class Session:
         sender: Optional[str] = None,
         dir: Optional[str] = None,
         llmconfig: Optional[Dict[str, Any]] = None,
-        service: OpenAIService = OAIService,
+        service: OpenAIService = None,
         branches: Optional[Dict[str, Branch]] = None,
         default_branch: Optional[Branch] = None,
         default_branch_name: str = 'main',
@@ -52,6 +52,9 @@ class Session:
         """
 
         self.branches = branches if isinstance(branches, dict) else {}
+        if service is None:
+            service = OpenAIService()
+        
         self.default_branch = default_branch if default_branch else Branch(name=default_branch_name, service=service, llmconfig=llmconfig)
         self.default_branch_name = default_branch_name
         if system:

{lionagi-0.0.205 → lionagi-0.0.206}/lionagi/loaders/chunker.py

@@ -140,7 +140,8 @@ def chunk(documents,
     elif chunker_type == ChunkerType.LLAMAINDEX:
         if documents_convert_func:
             documents = documents_convert_func(documents, 'llama_index')
-        nodes = llama_index_node_parser(documents, chunker, chunker_args, chunker_kwargs, chunking_kwargs)
+        nodes = llama_index_node_parser(documents, chunker, chunker_args, chunker_kwargs, chunking_kwargs)    
+            
         if isinstance(to_datanode, bool) and to_datanode is True:
             nodes = lcall(nodes, from_llama_index)
         elif isinstance(to_datanode, Callable):

{lionagi-0.0.205 → lionagi-0.0.206}/lionagi/tools/tool_manager.py

@@ -1,7 +1,7 @@
 import json
 import asyncio
 from typing import Dict, Union, List, Tuple, Any
-from lionagi.utils import lcall
+from lionagi.utils.call_util import lcall, is_coroutine_func, _call_handler
 from lionagi.schema import BaseNode, Tool
 
 
@@ -74,10 +74,10 @@ class ToolManager(BaseNode):
             func = tool.func
             parser = tool.parser
             try:
-                if asyncio.iscoroutinefunction(func):
-                    return await parser(func(**kwargs)) if parser else func(**kwargs)
-                else:
-                    return parser(func(**kwargs)) if parser else func(**kwargs)
+                tasks = [await _call_handler(func, **kwargs)]
+                out = await asyncio.gather(*tasks)
+                return parser(out) if parser else out
+            
             except Exception as e:
                 raise ValueError(f"Error when invoking function {name} with arguments {kwargs} with error message {e}")
         else: 

{lionagi-0.0.205 → lionagi-0.0.206}/lionagi/utils/__init__.py

@@ -1,7 +1,7 @@
 from .sys_util import (
     get_timestamp, create_copy, create_path, split_path, 
     get_bins, change_dict_key, str_to_num, create_id, 
-    as_dict)
+    as_dict, is_package_installed, install_import)
 
 from .nested_util import (
     to_readable_dict, nfilter, nset, nget, 
@@ -19,6 +19,7 @@ from .call_util import (
 
 
 __all__ = [
+    "is_package_installed", "install_import",
     'get_timestamp', 'create_copy', 'create_path', 'split_path',
     'get_bins', 'change_dict_key', 'str_to_num', 'create_id',
     'as_dict', 'to_list', 'to_readable_dict', 'nfilter', 'nset',

{lionagi-0.0.205 → lionagi-0.0.206}/lionagi/utils/call_util.py

@@ -2,6 +2,8 @@ import asyncio
 import functools
 import logging
 import time
+
+from concurrent.futures import ThreadPoolExecutor
 from typing import Any, Callable, Generator, Iterable, List, Dict, Optional, Tuple
 
 from aiocache import cached
@@ -643,6 +645,17 @@ class CallDecorator:
             reducing the frequency of resource-intensive operations.
         """
         return Throttle(period)
+    
+    @staticmethod
+    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 Throttle:
     """

{lionagi-0.0.205 → lionagi-0.0.206}/lionagi/utils/sys_util.py

@@ -1,15 +1,27 @@
 import os
+import subprocess
+import sys
 import copy
 from datetime import datetime
 import hashlib
 import re
-
+import importlib.util
+import platform
 import json
 import logging
 
 from typing import Any, List, Dict, Union
 
 
+
+def get_cpu_architecture():
+    arch = platform.machine()
+    if 'arm' in arch or 'aarch64' in arch:
+        return 'apple_silicon'
+    else:
+        return 'other_cpu'
+
+
 def get_timestamp() -> str:
     """
     Generates a current timestamp in ISO format with colons and periods replaced by 
@@ -352,3 +364,53 @@ def is_schema(dict_: Dict, schema: Dict):
 def timestamp_to_datetime(timestamp):    
     return datetime.fromtimestamp(timestamp)
 
+def install_import(package_name, module_name=None, import_name=None, pip_name=None):
+    
+    """
+    For a simple package import where package name matches pip name
+    import xx
+    install_and_import('xx')
+    
+
+    For importing a module from a package
+    import xx.yy
+    install_and_import('xx', 'yy')
+
+    For importing a specific attribute from a module/sub-module
+    from xx.yy import zz
+    install_and_import('xx', 'yy', 'zz')
+
+    For cases where pip name differs from package name
+    install_and_import('xx', pip_name='different_pip_name')
+
+    For full example with different pip name
+    install_and_import('xx', 'yy', 'zz', 'different_pip_name')
+    """
+    
+    if pip_name is None:
+        pip_name = package_name  # Defaults to package_name if pip_name is not explicitly provided
+    
+    full_import_path = package_name if module_name is None else f"{package_name}.{module_name}"
+    
+    try:
+        if import_name:
+            # For importing a specific name from a module or sub-module
+            module = __import__(full_import_path, fromlist=[import_name])
+            getattr(module, import_name)
+        else:
+            # For importing the module or package itself
+            __import__(full_import_path)
+        print(f"Successfully imported {import_name or full_import_path}.")
+    except ImportError:
+        print(f"Module {full_import_path} or attribute {import_name} not found. Installing {pip_name}...")
+        subprocess.check_call([sys.executable, "-m", "pip", "install", pip_name])
+        # Retry the import after installation
+        if import_name:
+            module = __import__(full_import_path, fromlist=[import_name])
+            getattr(module, import_name)
+        else:
+            __import__(full_import_path)
+            
+def is_package_installed(package_name):
+    package_spec = importlib.util.find_spec(package_name)
+    return package_spec is not None

lionagi-0.0.206/lionagi/version.py

@@ -0,0 +1 @@
+__version__ = "0.0.206"

{lionagi-0.0.205 → lionagi-0.0.206}/lionagi.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: lionagi
-Version: 0.0.205
+Version: 0.0.206
 Summary: Towards automated general intelligence.
 Author: HaiyangLi
 Author-email: Haiyang Li <ocean@lionagi.ai>

{lionagi-0.0.205 → lionagi-0.0.206}/lionagi.egg-info/SOURCES.txt

@@ -23,6 +23,7 @@ lionagi/_services/huggingface.py
 lionagi/_services/litellm.py
 lionagi/_services/localai.py
 lionagi/_services/mistralai.py
+lionagi/_services/mlx_service.py
 lionagi/_services/oai.py
 lionagi/_services/ollama.py
 lionagi/_services/openllm.py

lionagi-0.0.205/lionagi/_services/litellm.py

@@ -1 +0,0 @@
-# TODO

lionagi-0.0.205/lionagi/_services/ollama.py

@@ -1 +0,0 @@
-# TODO

lionagi-0.0.205/lionagi/_services/transformers.py

@@ -1,46 +0,0 @@
-from typing import Union, 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-0.0.205/lionagi/version.py

@@ -1 +0,0 @@
-__version__ = "0.0.205"