lionagi 0.12.3__py3-none-any.whl → 0.12.5__py3-none-any.whl

lionagi/adapters/pandas_/pd_dataframe_adapter.py

@@ -1,81 +0,0 @@
-"""
-Defines a `PandasDataFrameAdapter` that converts between
-a DataFrame and a list of dictionary-based elements.
-"""
-
-from datetime import datetime
-
-import pandas as pd
-
-from ..adapter import Adapter, T
-
-
-class PandasDataFrameAdapter(Adapter):
-    """
-    Converts a set of objects to a single `pd.DataFrame`, or
-    a DataFrame to a list of dictionaries. Typically used in memory,
-    not for saving to file.
-    """
-
-    obj_key = "pd_dataframe"
-    alias = ("pandas_dataframe", "pd.DataFrame", "pd_dataframe")
-
-    @classmethod
-    def from_obj(
-        cls, subj_cls: type[T], obj: pd.DataFrame, /, **kwargs
-    ) -> list[dict]:
-        """
-        Convert an existing DataFrame into a list of dicts.
-
-        Parameters
-        ----------
-        subj_cls : type[T]
-            The internal class to which we might parse.
-        obj : pd.DataFrame
-            The DataFrame to convert.
-        **kwargs
-            Additional args for DataFrame.to_dict (like `orient`).
-
-        Returns
-        -------
-        list[dict]
-            Each row as a dictionary.
-        """
-        return obj.to_dict(orient="records", **kwargs)
-
-    @classmethod
-    def to_obj(cls, subj: list[T], /, **kwargs) -> pd.DataFrame:
-        """
-        Convert multiple items into a DataFrame, adjusting `created_at` to datetime.
-
-        Parameters
-        ----------
-        subj : list[T]
-            The items to convert. Each item must have `to_dict()`.
-        **kwargs
-            Additional arguments for `pd.DataFrame(...)`.
-
-        Returns
-        -------
-        pd.DataFrame
-            The resulting DataFrame.
-        """
-        out_ = []
-        for i in subj:
-            _dict = i.to_dict()
-            # Attempt to parse timestamps
-            if "created_at" in _dict:
-                try:
-                    _dict["created_at"] = datetime.fromtimestamp(
-                        _dict["created_at"]
-                    )
-                except Exception:
-                    pass
-            out_.append(_dict)
-        df = pd.DataFrame(out_, **kwargs)
-        # Convert created_at to datetime if present
-        if "created_at" in df.columns:
-            df["created_at"] = pd.to_datetime(
-                df["created_at"], errors="coerce"
-            )
-        return df

lionagi/adapters/pandas_/pd_series_adapter.py

@@ -1,57 +0,0 @@
-"""
-Defines a `PandasSeriesAdapter` that converts a single object
-to/from a `pd.Series`.
-"""
-
-import pandas as pd
-
-from ..adapter import Adapter, T
-
-
-class PandasSeriesAdapter(Adapter):
-    """
-    Converts a single item to a Pandas Series and vice versa.
-    Great for 1-row data or simpler key-value pairs.
-    """
-
-    obj_key = "pd_series"
-    alias = ("pandas_series", "pd.series", "pd_series")
-
-    @classmethod
-    def from_obj(cls, subj_cls: type[T], obj: pd.Series, /, **kwargs) -> dict:
-        """
-        Convert a Pandas Series into a dictionary.
-
-        Parameters
-        ----------
-        subj_cls : type[T]
-            Possibly the class we might use to rehydrate the item.
-        obj : pd.Series
-            The series to interpret.
-        **kwargs
-            Additional arguments for `Series.to_dict`.
-
-        Returns
-        -------
-        dict
-            The data from the Series as a dictionary.
-        """
-        return obj.to_dict(**kwargs)
-
-    @classmethod
-    def to_obj(cls, subj: T, /, **kwargs) -> pd.Series:
-        """
-        Convert a single item to a Series.
-
-        Parameters
-        ----------
-        subj : T
-            The item, which must have `to_dict()`.
-        **kwargs
-            Extra args passed to `pd.Series`.
-
-        Returns
-        -------
-        pd.Series
-        """
-        return pd.Series(subj.to_dict(), **kwargs)

lionagi/adapters/toml_adapter.py

@@ -1,204 +0,0 @@
-"""
-Implements two adapters:
-- `TomlAdapter` for in-memory TOML strings
-- `TomlFileAdapter` for reading/writing TOML files
-"""
-
-import logging
-from pathlib import Path
-
-import toml
-
-from lionagi.protocols._concepts import Collective
-
-from .adapter import Adapter, T
-
-
-class TomlAdapter(Adapter):
-    """
-    Adapter that converts to/from TOML **strings** in memory.
-    Example usage: taking a Python dictionary and making TOML,
-    or parsing TOML string to a dict.
-    """
-
-    obj_key = "toml"
-
-    @classmethod
-    def from_obj(
-        cls,
-        subj_cls: type[T],
-        obj: str,
-        /,
-        *,
-        many: bool = False,
-        **kwargs,
-    ) -> dict | list[dict]:
-        """
-        Convert a TOML string into a dict or list of dicts.
-
-        Parameters
-        ----------
-        subj_cls : type[T]
-            The target class for context (not always used).
-        obj : str
-            The TOML string.
-        many : bool, optional
-            If True, expects a TOML array of tables (returns list[dict]).
-            Otherwise returns a single dict.
-        **kwargs
-            Extra arguments for toml.loads().
-
-        Returns
-        -------
-        dict | list[dict]
-            The loaded TOML data.
-        """
-        result = toml.loads(obj, **kwargs)
-
-        # Handle array of tables in TOML for "many" case
-        if many:
-            # Check if there's a top-level array key that might hold multiple items
-            for key, value in result.items():
-                if isinstance(value, list) and all(
-                    isinstance(item, dict) for item in value
-                ):
-                    return value
-            # If no array of tables found, wrap the result in a list
-            return [result]
-
-        return result
-
-    @classmethod
-    def to_obj(
-        cls,
-        subj: T,
-        *,
-        many: bool = False,
-        **kwargs,
-    ) -> str:
-        """
-        Convert an object (or collection) to a TOML string.
-
-        Parameters
-        ----------
-        subj : T
-            The object to serialize.
-        many : bool, optional
-            If True, convert multiple items to a TOML array of tables.
-        **kwargs
-            Extra arguments for toml.dumps().
-
-        Returns
-        -------
-        str
-            The resulting TOML string.
-        """
-        if many:
-            if isinstance(subj, Collective):
-                # For multiple items, create a wrapper dict with an array of items
-                data = {"items": [i.to_dict() for i in subj]}
-            else:
-                data = {"items": [subj.to_dict()]}
-            return toml.dumps(data, **kwargs)
-
-        return toml.dumps(subj.to_dict(), **kwargs)
-
-
-class TomlFileAdapter(Adapter):
-    """
-    Adapter that reads/writes TOML data to/from a file on disk.
-    The file extension key is ".toml".
-    """
-
-    obj_key = ".toml"
-
-    @classmethod
-    def from_obj(
-        cls,
-        subj_cls: type[T],
-        obj: str | Path,
-        /,
-        *,
-        many: bool = False,
-        **kwargs,
-    ) -> dict | list[dict]:
-        """
-        Read a TOML file from disk and return a dict or list of dicts.
-
-        Parameters
-        ----------
-        subj_cls : type[T]
-            The target class for context.
-        obj : str | Path
-            The TOML file path.
-        many : bool
-            If True, expects an array of tables. Otherwise single dict.
-        **kwargs
-            Extra arguments for toml.load().
-
-        Returns
-        -------
-        dict | list[dict]
-            The loaded data from file.
-        """
-        with open(obj, encoding="utf-8") as f:
-            result = toml.load(f, **kwargs)
-
-        # Handle array of tables in TOML for "many" case
-        if many:
-            # Check if there's a top-level array key that might hold multiple items
-            for key, value in result.items():
-                if isinstance(value, list) and all(
-                    isinstance(item, dict) for item in value
-                ):
-                    return value
-            # If no array of tables found, wrap the result in a list
-            return [result]
-
-        return result
-
-    @classmethod
-    def to_obj(
-        cls,
-        subj: T,
-        /,
-        *,
-        fp: str | Path,
-        many: bool = False,
-        mode: str = "w",
-        **kwargs,
-    ) -> None:
-        """
-        Write a dict (or list) to a TOML file.
-
-        Parameters
-        ----------
-        subj : T
-            The object/collection to serialize.
-        fp : str | Path
-            The file path to write.
-        many : bool
-            If True, write as a TOML array of tables of multiple items.
-        mode : str
-            File open mode, defaults to write ("w").
-        **kwargs
-            Extra arguments for toml.dump().
-
-        Returns
-        -------
-        None
-        """
-        with open(fp, mode, encoding="utf-8") as f:
-            if many:
-                if isinstance(subj, Collective):
-                    # TOML requires arrays of tables to be in a table
-                    data = {"items": [i.to_dict() for i in subj]}
-                else:
-                    data = {"items": [subj.to_dict()]}
-                toml.dump(data, f, **kwargs)
-            else:
-                toml.dump(subj.to_dict(), f, **kwargs)
-        logging.info(f"TOML data saved to {fp}")
-
-
-# File: lionagi/protocols/adapters/toml_adapter.py

lionagi/adapters/types.py

@@ -1,21 +0,0 @@
-from .adapter import ADAPTER_MEMBERS, Adapter, AdapterRegistry
-from .json_adapter import JsonAdapter, JsonFileAdapter
-from .pandas_.csv_adapter import CSVFileAdapter
-from .pandas_.excel_adapter import ExcelFileAdapter
-from .pandas_.pd_dataframe_adapter import PandasDataFrameAdapter
-from .pandas_.pd_series_adapter import PandasSeriesAdapter
-from .toml_adapter import TomlAdapter, TomlFileAdapter
-
-__all__ = (
-    "Adapter",
-    "AdapterRegistry",
-    "ADAPTER_MEMBERS",
-    "JsonAdapter",
-    "JsonFileAdapter",
-    "CSVFileAdapter",
-    "PandasSeriesAdapter",
-    "PandasDataFrameAdapter",
-    "ExcelFileAdapter",
-    "TomlAdapter",
-    "TomlFileAdapter",
-)

lionagi/service/endpoints/__init__.py

@@ -1,3 +0,0 @@
-# Copyright (c) 2023 - 2025, HaiyangLi <quantocean.li at gmail dot com>
-#
-# SPDX-License-Identifier: Apache-2.0