lionagi 0.0.314__tar.gz → 0.0.315__tar.gz

{lionagi-0.0.314/lionagi.egg-info → lionagi-0.0.315}/PKG-INFO

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

{lionagi-0.0.314 → lionagi-0.0.315}/lionagi/__init__.py

@@ -8,6 +8,9 @@ from dotenv import load_dotenv
 
 from .core import direct, Branch, Session, func_to_tool
 from .integrations.provider.services import Services
+from .integrations.chunker.chunk import chunk
+from .integrations.loader.load import load
+
 
 logger = logging.getLogger(__name__)
 logger.setLevel(logging.INFO)

lionagi-0.0.315/lionagi/core/direct/cot.py

@@ -0,0 +1 @@
+# TODO: chain of thoughts

{lionagi-0.0.314 → lionagi-0.0.315}/lionagi/core/direct/react.py

@@ -159,7 +159,7 @@ async def react(
             return_branch=return_branch,
             **kwargs,
         )
-        
+
     if num_instances == 1:
         return await _inner()
 

{lionagi-0.0.314 → lionagi-0.0.315}/lionagi/core/direct/select.py

@@ -39,9 +39,7 @@ class SelectTemplate(ScoredTemplate):
     answer: Enum | str = Field(
         default_factory=str, description="selection from given choices"
     )
-    choices: list = Field(
-        default_factory=list, description="the given choices"
-    )
+    choices: list = Field(default_factory=list, description="the given choices")
 
     signature: str = "sentence -> answer"
 

lionagi-0.0.315/lionagi/core/direct/sentiment.py

@@ -0,0 +1 @@
+# TODO: sentiment analysis

{lionagi-0.0.314 → lionagi-0.0.315}/lionagi/integrations/bridge/llamaindex_/node_parser.py

@@ -29,19 +29,18 @@ def get_llama_index_node_parser(node_parser: Any):
     import llama_index.core.node_parser
 
     if not isinstance(node_parser, str) and not issubclass(node_parser, NodeParser):
-        raise TypeError(f"node_parser must be a string or NodeParser.")
+        raise TypeError("node_parser must be a string or NodeParser.")
 
     if isinstance(node_parser, str):
         if node_parser == "CodeSplitter":
             SysUtil.check_import("tree_sitter_languages")
 
         try:
-            parser = getattr(llama_index.core.node_parser, node_parser)
-            return parser
+            return getattr(llama_index.core.node_parser, node_parser)
         except Exception as e:
             raise AttributeError(
                 f"llama_index_core has no such attribute:" f" {node_parser}, Error: {e}"
-            )
+            ) from e
 
     elif isinstance(node_parser, NodeParser):
         return node_parser
@@ -75,10 +74,8 @@ def llama_index_parse_node(
         parser = get_llama_index_node_parser(node_parser)
         try:
             parser = parser(*parser_args, **parser_kwargs)
-        except:
+        except Exception:
             parser = parser.from_defaults(*parser_args, **parser_kwargs)
-        nodes = parser.get_nodes_from_documents(documents)
-        return nodes
-
+        return parser.get_nodes_from_documents(documents)
     except Exception as e:
-        raise ValueError(f"Failed to parse. Error: {e}")
+        raise ValueError(f"Failed to parse. Error: {e}") from e

lionagi-0.0.315/lionagi/integrations/chunker/chunk.py

@@ -0,0 +1,175 @@
+from typing import Union, Callable
+
+from lionagi.libs import func_call
+from lionagi.core.schema import DataNode
+from ..bridge.langchain_.langchain_bridge import LangchainBridge
+from ..bridge.llamaindex_.llama_index_bridge import LlamaIndexBridge
+
+
+from ..loader.load_util import ChunkerType, file_to_chunks, _datanode_parser
+
+
+def datanodes_convert(documents, chunker_type):
+
+    for i in range(len(documents)):
+        if type(documents[i]) == DataNode:
+            if chunker_type == ChunkerType.LLAMAINDEX:
+                documents[i] = documents[i].to_llama_index()
+            elif chunker_type == ChunkerType.LANGCHAIN:
+                documents[i] = documents[i].to_langchain()
+    return documents
+
+
+def text_chunker(documents, args, kwargs):
+
+    def chunk_node(node):
+        chunks = file_to_chunks(node.to_dict(), *args, **kwargs)
+        func_call.lcall(chunks, lambda chunk: chunk.pop("node_id"))
+        return [DataNode.from_obj({**chunk}) for chunk in chunks]
+
+    return [chunk_node(doc) for doc in documents]
+
+
+def chunk(
+    documents,
+    chunker,
+    chunker_type=ChunkerType.PLAIN,
+    chunker_args=None,
+    chunker_kwargs=None,
+    chunking_kwargs=None,
+    documents_convert_func=None,
+    to_datanode: bool | Callable = True,
+):
+
+    if chunker_args is None:
+        chunker_args = []
+    if chunker_kwargs is None:
+        chunker_kwargs = {}
+    if chunking_kwargs is None:
+        chunking_kwargs = {}
+
+    if chunker_type == ChunkerType.PLAIN:
+        return chunk_funcs[ChunkerType.PLAIN](
+            documents, chunker, chunker_args, chunker_kwargs
+        )
+
+    elif chunker_type == ChunkerType.LANGCHAIN:
+        return chunk_funcs[ChunkerType.LANGCHAIN](
+            documents,
+            documents_convert_func,
+            chunker,
+            chunker_args,
+            chunker_kwargs,
+            to_datanode,
+        )
+
+    elif chunker_type == ChunkerType.LLAMAINDEX:
+        return chunk_funcs[ChunkerType.LLAMAINDEX](
+            documents,
+            documents_convert_func,
+            chunker,
+            chunker_args,
+            chunker_kwargs,
+            to_datanode,
+        )
+
+    elif chunker_type == ChunkerType.SELFDEFINED:
+        return chunk_funcs[ChunkerType.SELFDEFINED](
+            documents,
+            chunker,
+            chunker_args,
+            chunker_kwargs,
+            chunking_kwargs,
+            to_datanode,
+        )
+
+    else:
+        raise ValueError(
+            f"{chunker_type} is not supported. Please choose from {list(ChunkerType)}"
+        )
+
+
+def _self_defined_chunker(
+    documents,
+    chunker,
+    chunker_args,
+    chunker_kwargs,
+    chunking_kwargs,
+    to_datanode: bool | Callable,
+):
+    try:
+        splitter = chunker(*chunker_args, **chunker_kwargs)
+        nodes = splitter.split(documents, **chunking_kwargs)
+    except Exception as e:
+        raise ValueError(
+            f"Self defined chunker {chunker} is not valid. Error: {e}"
+        ) from e
+
+    if isinstance(to_datanode, bool) and to_datanode is True:
+        raise ValueError("Please define a valid parser to DataNode.")
+    elif isinstance(to_datanode, Callable):
+        nodes = _datanode_parser(nodes, to_datanode)
+    return nodes
+
+
+def _llama_index_chunker(
+    documents,
+    documents_convert_func,
+    chunker,
+    chunker_args,
+    chunker_kwargs,
+    to_datanode: bool | Callable,
+):
+    if documents_convert_func:
+        documents = documents_convert_func(documents, "llama_index")
+    nodes = LlamaIndexBridge.llama_index_parse_node(
+        documents, chunker, chunker_args, chunker_kwargs
+    )
+
+    if isinstance(to_datanode, bool) and to_datanode is True:
+        nodes = [DataNode.from_llama_index(i) for i in nodes]
+    elif isinstance(to_datanode, Callable):
+        nodes = _datanode_parser(nodes, to_datanode)
+    return nodes
+
+
+def _langchain_chunker(
+    documents,
+    documents_convert_func,
+    chunker,
+    chunker_args,
+    chunker_kwargs,
+    to_datanode: bool | Callable,
+):
+    if documents_convert_func:
+        documents = documents_convert_func(documents, "langchain")
+    nodes = LangchainBridge.langchain_text_splitter(
+        documents, chunker, chunker_args, chunker_kwargs
+    )
+    if isinstance(to_datanode, bool) and to_datanode is True:
+        if isinstance(documents, str):
+            nodes = [DataNode(content=i) for i in nodes]
+        else:
+            nodes = [DataNode.from_langchain(i) for i in nodes]
+    elif isinstance(to_datanode, Callable):
+        nodes = _datanode_parser(nodes, to_datanode)
+    return nodes
+
+
+def _plain_chunker(documents, chunker, chunker_args, chunker_kwargs):
+    try:
+        if chunker == "text_chunker":
+            chunker = text_chunker
+        return chunker(documents, chunker_args, chunker_kwargs)
+    except Exception as e:
+        raise ValueError(
+            f"Reader {chunker} is currently not supported. Error: {e}"
+        ) from e
+
+
+chunk_funcs = {
+    ChunkerType.PLAIN: _plain_chunker,
+    ChunkerType.LANGCHAIN: _langchain_chunker,
+    ChunkerType.LLAMAINDEX: _llama_index_chunker,
+    ChunkerType.SELFDEFINED: _self_defined_chunker,
+}

lionagi-0.0.315/lionagi/integrations/loader/load.py

@@ -0,0 +1,152 @@
+from typing import Callable
+
+from lionagi.core.schema import DataNode
+from ..bridge.langchain_.langchain_bridge import LangchainBridge
+from ..bridge.llamaindex_.llama_index_bridge import LlamaIndexBridge
+
+from .load_util import dir_to_nodes, ReaderType, _datanode_parser
+
+
+def text_reader(args, kwargs):
+    """
+    Reads text files from a directory and converts them to DataNode instances.
+
+    Args:
+        args: Positional arguments for the dir_to_nodes function.
+        kwargs: Keyword arguments for the dir_to_nodes function.
+
+    Returns:
+        A list of DataNode instances.
+
+    Example usage:
+        >>> args = ['path/to/text/files']
+        >>> kwargs = {'file_extension': 'txt'}
+        >>> nodes = text_reader(args, kwargs)
+    """
+    return dir_to_nodes(*args, **kwargs)
+
+
+def load(
+    reader: str | Callable = "SimpleDirectoryReader",
+    input_dir=None,
+    input_files=None,
+    recursive: bool = False,
+    required_exts: list[str] = None,
+    reader_type=ReaderType.LLAMAINDEX,
+    reader_args=None,
+    reader_kwargs=None,
+    load_args=None,
+    load_kwargs=None,
+    to_datanode: bool | Callable = True,
+):
+
+    if reader_args is None:
+        reader_args = []
+    if reader_kwargs is None:
+        reader_kwargs = {}
+    if load_args is None:
+        load_args = []
+    if load_kwargs is None:
+        load_kwargs = {}
+
+    if reader_type == ReaderType.PLAIN:
+        return read_funcs[ReaderType.PLAIN](reader, reader_args, reader_kwargs)
+
+    if reader_type == ReaderType.LANGCHAIN:
+        return read_funcs[ReaderType.LANGCHAIN](
+            reader, reader_args, reader_kwargs, to_datanode
+        )
+
+    elif reader_type == ReaderType.LLAMAINDEX:
+        if input_dir is not None:
+            reader_kwargs["input_dir"] = input_dir
+        if input_files is not None:
+            reader_kwargs["input_files"] = input_files
+        if recursive:
+            reader_kwargs["recursive"] = True
+        if required_exts is not None:
+            reader_kwargs["required_exts"] = required_exts
+
+        return read_funcs[ReaderType.LLAMAINDEX](
+            reader, reader_args, reader_kwargs, load_args, load_kwargs, to_datanode
+        )
+
+    elif reader_type == ReaderType.SELFDEFINED:
+        return read_funcs[ReaderType.SELFDEFINED](
+            reader, reader_args, reader_kwargs, load_args, load_kwargs, to_datanode
+        )
+
+    else:
+        raise ValueError(
+            f"{reader_type} is not supported. Please choose from {list(ReaderType)}"
+        )
+
+
+def _plain_reader(reader, reader_args, reader_kwargs):
+    try:
+        if reader == "text_reader":
+            reader = text_reader
+        return reader(reader_args, reader_kwargs)
+    except Exception as e:
+        raise ValueError(
+            f"Reader {reader} is currently not supported. Error: {e}"
+        ) from e
+
+
+def _langchain_reader(reader, reader_args, reader_kwargs, to_datanode: bool | Callable):
+    nodes = LangchainBridge.langchain_loader(reader, reader_args, reader_kwargs)
+    if isinstance(to_datanode, bool) and to_datanode is True:
+        nodes = [DataNode.from_langchain(i) for i in nodes]
+
+    elif isinstance(to_datanode, Callable):
+        nodes = _datanode_parser(nodes, to_datanode)
+    return nodes
+
+
+def _llama_index_reader(
+    reader,
+    reader_args,
+    reader_kwargs,
+    load_args,
+    load_kwargs,
+    to_datanode: bool | Callable,
+):
+    nodes = LlamaIndexBridge.llama_index_read_data(
+        reader, reader_args, reader_kwargs, load_args, load_kwargs
+    )
+    if isinstance(to_datanode, bool) and to_datanode is True:
+        nodes = [DataNode.from_llama_index(i) for i in nodes]
+    elif isinstance(to_datanode, Callable):
+        nodes = _datanode_parser(nodes, to_datanode)
+    return nodes
+
+
+def _self_defined_reader(
+    reader,
+    reader_args,
+    reader_kwargs,
+    load_args,
+    load_kwargs,
+    to_datanode: bool | Callable,
+):
+    try:
+        loader = reader(*reader_args, **reader_kwargs)
+        nodes = loader.load(*load_args, **load_kwargs)
+    except Exception as e:
+        raise ValueError(
+            f"Self defined reader {reader} is not valid. Error: {e}"
+        ) from e
+
+    if isinstance(to_datanode, bool) and to_datanode is True:
+        raise ValueError("Please define a valid parser to DataNode.")
+    elif isinstance(to_datanode, Callable):
+        nodes = _datanode_parser(nodes, to_datanode)
+    return nodes
+
+
+read_funcs = {
+    ReaderType.PLAIN: _plain_reader,
+    ReaderType.LANGCHAIN: _langchain_reader,
+    ReaderType.LLAMAINDEX: _llama_index_reader,
+    ReaderType.SELFDEFINED: _self_defined_reader,
+}

lionagi-0.0.315/lionagi/integrations/loader/load_util.py

@@ -0,0 +1,266 @@
+# use utils and schema
+import math
+from enum import Enum
+from pathlib import Path
+from typing import List, Union, Dict, Any, Tuple
+
+from lionagi.libs import convert, func_call
+from lionagi.core.schema import DataNode
+
+
+class ReaderType(str, Enum):
+    PLAIN = "plain"
+    LANGCHAIN = "langchain"
+    LLAMAINDEX = "llama_index"
+    SELFDEFINED = "self_defined"
+
+
+class ChunkerType(str, Enum):
+    PLAIN = "plain"  # default
+    LANGCHAIN = "langchain"  # using langchain functions
+    LLAMAINDEX = "llama_index"  # using llamaindex functions
+    SELFDEFINED = "self_defined"  # create custom functions
+
+
+def dir_to_path(
+    dir: str, ext: str, recursive: bool = False, flatten: bool = True
+) -> List[Path]:
+    """
+    Generates a list of file paths from a directory with the given file extension.
+
+    Parameters:
+        dir (str): The directory to search for files.
+
+        ext (str): The file extension to filter by.
+
+        recursive (bool): Whether to search subdirectories recursively. Defaults to False.
+
+        flatten (bool): Whether to flatten the list. Defaults to True.
+
+    Returns:
+        List[Path]: A list of Paths to the files.
+
+    Raises:
+        ValueError: If the directory or extension is invalid.
+    """
+
+    def _dir_to_path(ext):
+        tem = "**/*" if recursive else "*"
+        return list(Path(dir).glob(tem + ext))
+
+    try:
+        return convert.to_list(
+            func_call.lcall(ext, _dir_to_path, flatten=True), flatten=flatten
+        )
+    except:
+        raise ValueError("Invalid directory or extension, please check the path")
+
+
+def dir_to_nodes(
+    dir: str,
+    ext: Union[List[str], str],
+    recursive: bool = False,
+    flatten: bool = True,
+    clean_text: bool = True,
+) -> List[DataNode]:
+    """
+    Converts directory contents into DataNode objects based on specified file extensions.
+
+    This function first retrieves a list of file paths from the specified directory, matching the given file extension. It then reads the content of these files, optionally cleaning the text, and converts each file's content into a DataNode object.
+
+    Parameters:
+        dir (str): The directory path from which to read files.
+        ext: The file extension(s) to include. Can be a single string or a list/tuple of strings.
+        recursive (bool, optional): If True, the function searches for files recursively in subdirectories. Defaults to False.
+        flatten (bool, optional): If True, flattens the directory structure in the returned paths. Defaults to True.
+        clean_text (bool, optional): If True, cleans the text read from files. Defaults to True.
+
+    Returns:
+        list: A list of DataNode objects created from the files in the specified directory.
+
+    Example:
+        nodes = dir_to_nodes("/path/to/dir", ".txt", recursive=True)
+        # This would read all .txt files in /path/to/dir and its subdirectories,
+        # converting them into DataNode objects.
+    """
+
+    path_list = dir_to_path(dir, ext, recursive, flatten)
+    files_info = func_call.lcall(path_list, read_text, clean=clean_text)
+    return func_call.lcall(files_info, lambda x: DataNode(content=x[0], metadata=x[1]))
+
+
+def chunk_text(
+    input: str, chunk_size: int, overlap: float, threshold: int
+) -> List[Union[str, None]]:
+    """
+    Chunks the input text into smaller parts, with optional overlap and threshold for final chunk.
+
+    Parameters:
+        input (str): The input text to chunk.
+
+        chunk_size (int): The size of each chunk.
+
+        overlap (float): The amount of overlap between chunks.
+
+        threshold (int): The minimum size of the final chunk.
+
+    Returns:
+        List[Union[str, None]]: A list of text chunks.
+
+    Raises:
+        ValueError: If an error occurs during chunking.
+    """
+
+    def _chunk_n1():
+        return [input]
+
+    def _chunk_n2():
+        chunks = []
+        chunks.append(input[: chunk_size + overlap_size])
+
+        if len(input) - chunk_size > threshold:
+            chunks.append(input[chunk_size - overlap_size :])
+        else:
+            return _chunk_n1()
+
+        return chunks
+
+    def _chunk_n3():
+        chunks = []
+        chunks.append(input[: chunk_size + overlap_size])
+        for i in range(1, n_chunks - 1):
+            start_idx = chunk_size * i - overlap_size
+            end_idx = chunk_size * (i + 1) + overlap_size
+            chunks.append(input[start_idx:end_idx])
+
+        if len(input) - chunk_size * (n_chunks - 1) > threshold:
+            chunks.append(input[chunk_size * (n_chunks - 1) - overlap_size :])
+        else:
+            chunks[-1] += input[chunk_size * (n_chunks - 1) + overlap_size :]
+
+        return chunks
+
+    try:
+        if not isinstance(input, str):
+            input = convert.to_str(input)
+
+        n_chunks = math.ceil(len(input) / chunk_size)
+        overlap_size = int(overlap / 2)
+
+        if n_chunks == 1:
+            return _chunk_n1()
+
+        elif n_chunks == 2:
+            return _chunk_n2()
+
+        elif n_chunks > 2:
+            return _chunk_n3()
+
+    except Exception as e:
+        raise ValueError(f"An error occurred while chunking the text. {e}")
+
+
+def read_text(filepath: str, clean: bool = True) -> Tuple[str, dict]:
+    """
+    Reads text from a file and optionally cleans it, returning the content and metadata.
+
+    Parameters:
+        filepath (str): The path to the file to read.
+
+        clean (bool): Whether to clean the text by replacing certain characters. Defaults to True.
+
+    Returns:
+        Tuple[str, dict]: A tuple containing the content and metadata of the file.
+
+    Raises:
+        FileNotFoundError: If the file cannot be found.
+
+        PermissionError: If there are permissions issues.
+
+        OSError: For other OS-related errors.
+    """
+
+    def _get_metadata():
+        import os
+        from datetime import datetime
+
+        file = filepath
+        size = os.path.getsize(filepath)
+        creation_date = datetime.fromtimestamp(os.path.getctime(filepath)).date()
+        modified_date = datetime.fromtimestamp(os.path.getmtime(filepath)).date()
+        last_accessed_date = datetime.fromtimestamp(os.path.getatime(filepath)).date()
+        return {
+            "file": convert.to_str(file),
+            "size": size,
+            "creation_date": str(creation_date),
+            "modified_date": str(modified_date),
+            "last_accessed_date": str(last_accessed_date),
+        }
+
+    try:
+        with open(filepath, "r") as f:
+            content = f.read()
+            if clean:
+                # Define characters to replace and their replacements
+                replacements = {"\\": " ", "\n": " ", "\t": " ", "  ": " ", "'": " "}
+                for old, new in replacements.items():
+                    content = content.replace(old, new)
+            metadata = _get_metadata()
+            return content, metadata
+    except Exception as e:
+        raise e
+
+
+def _file_to_chunks(
+    input: Dict[str, Any],
+    field: str = "content",
+    chunk_size: int = 1500,
+    overlap: float = 0.1,
+    threshold: int = 200,
+) -> List[Dict[str, Any]]:
+    try:
+        out = {key: value for key, value in input.items() if key != field} | {
+            "chunk_overlap": overlap,
+            "chunk_threshold": threshold,
+        }
+        chunks = chunk_text(
+            input[field], chunk_size=chunk_size, overlap=overlap, threshold=threshold
+        )
+        logs = []
+        for i, chunk in enumerate(chunks):
+            chunk_dict = out | {
+                "file_chunks": len(chunks),
+                "chunk_id": i + 1,
+                "chunk_size": len(chunk),
+                f"chunk_{field}": chunk,
+            }
+            logs.append(chunk_dict)
+
+        return logs
+
+    except Exception as e:
+        raise ValueError(f"An error occurred while chunking the file. {e}") from e
+
+
+# needs doing TODO
+def file_to_chunks(
+    input,
+    #    project='project',
+    #    output_dir='data/logs/sources/',
+    chunk_func=_file_to_chunks,
+    **kwargs,
+):
+    #    out_to_csv=False,
+    #    filename=None,
+    #    verbose=True,
+    #    timestamp=True,
+    #    logger=None,
+    return convert.to_list(func_call.lcall(input, chunk_func, **kwargs), flatten=True)
+
+
+def _datanode_parser(nodes, parser):
+
+    try:
+        return parser(nodes)
+    except Exception as e:
+        raise ValueError(f"DataNode parser {parser} failed. Error:{e}") from e

lionagi-0.0.315/lionagi/version.py

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

{lionagi-0.0.314 → lionagi-0.0.315/lionagi.egg-info}/PKG-INFO

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

{lionagi-0.0.314 → lionagi-0.0.315}/lionagi.egg-info/SOURCES.txt

@@ -21,10 +21,13 @@ lionagi/core/branch/executable_branch.py
 lionagi/core/branch/util.py
 lionagi/core/branch/base/__init__.py
 lionagi/core/direct/__init__.py
+lionagi/core/direct/cot.py
+lionagi/core/direct/plan.py
 lionagi/core/direct/predict.py
 lionagi/core/direct/react.py
 lionagi/core/direct/score.py
 lionagi/core/direct/select.py
+lionagi/core/direct/sentiment.py
 lionagi/core/direct/utils.py
 lionagi/core/direct/vote.py
 lionagi/core/flow/__init__.py
@@ -74,11 +77,16 @@ lionagi/integrations/bridge/llamaindex_/reader.py
 lionagi/integrations/bridge/llamaindex_/textnode.py
 lionagi/integrations/bridge/pydantic_/__init__.py
 lionagi/integrations/bridge/pydantic_/pydantic_bridge.py
+lionagi/integrations/chunker/__init__.py
+lionagi/integrations/chunker/chunk.py
 lionagi/integrations/config/__init__.py
 lionagi/integrations/config/mlx_configs.py
 lionagi/integrations/config/oai_configs.py
 lionagi/integrations/config/ollama_configs.py
 lionagi/integrations/config/openrouter_configs.py
+lionagi/integrations/loader/__init__.py
+lionagi/integrations/loader/load.py
+lionagi/integrations/loader/load_util.py
 lionagi/integrations/provider/__init__.py
 lionagi/integrations/provider/litellm.py
 lionagi/integrations/provider/mistralai.py

lionagi-0.0.314/lionagi/version.py

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