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

lionagi/protocols/generic/pile.py

@@ -5,6 +5,7 @@
 from __future__ import annotations
 
 import asyncio
+import json
 import threading
 from collections import deque
 from collections.abc import (
@@ -21,18 +22,13 @@ from typing import Any, ClassVar, Generic, TypeVar
 import pandas as pd
 from pydantic import Field
 from pydantic.fields import FieldInfo
+from pydapter import Adapter, AdapterRegistry
+from pydapter.adapters import CsvAdapter, JsonAdapter
+from pydapter.extras.excel_ import ExcelAdapter
+from pydapter.extras.pandas_ import DataFrameAdapter
 from typing_extensions import Self, override
 
 from lionagi._errors import ItemExistsError, ItemNotFoundError
-from lionagi.adapters.types import (
-    Adapter,
-    AdapterRegistry,
-    CSVFileAdapter,
-    ExcelFileAdapter,
-    JsonAdapter,
-    JsonFileAdapter,
-    PandasDataFrameAdapter,
-)
 from lionagi.utils import UNDEFINED, is_same_dtype, to_list
 
 from .._concepts import Observable
@@ -45,10 +41,9 @@ T = TypeVar("T", bound=E)
 
 PILE_DEFAULT_ADAPTERS = (
     JsonAdapter,
-    JsonFileAdapter,
-    CSVFileAdapter,
-    ExcelFileAdapter,
-    PandasDataFrameAdapter,
+    CsvAdapter,
+    ExcelAdapter,
+    DataFrameAdapter,
 )
 
 
@@ -56,8 +51,9 @@ class PileAdapterRegistry(AdapterRegistry):
     pass
 
 
+pile_adapter_registry = PileAdapterRegistry()
 for i in PILE_DEFAULT_ADAPTERS:
-    PileAdapterRegistry.register(i)
+    pile_adapter_registry.register(i)
 
 
 __all__ = (
@@ -117,7 +113,7 @@ class Pile(Element, Collective[E], Generic[E]):
         frozen=True,
     )
 
-    _adapter_registry: ClassVar[AdapterRegistry] = PileAdapterRegistry
+    _adapter_registry: ClassVar[AdapterRegistry] = pile_adapter_registry
 
     def __pydantic_extra__(self) -> dict[str, FieldInfo]:
         return {
@@ -966,12 +962,25 @@ class Pile(Element, Collective[E], Generic[E]):
 
     def adapt_to(self, obj_key: str, /, **kwargs: Any) -> Any:
         """Convert to another format."""
-        return self._get_adapter_registry().adapt_to(self, obj_key, **kwargs)
+        # For JSON adapter, we need to pass the dict representation
+        if obj_key in ["json", "csv", "toml"]:
+            data = self.to_dict()
 
-    @classmethod
-    def list_adapters(cls):
-        """List available adapters."""
-        return cls._get_adapter_registry().list_adapters()
+            # Create a simple object that has model_dump method
+            class _Wrapper:
+                def __init__(self, data):
+                    self._data = data
+
+                def model_dump(self):
+                    return self._data
+
+            wrapper = _Wrapper(data)
+            return self._get_adapter_registry().adapt_to(
+                wrapper, obj_key=obj_key, **kwargs
+            )
+        return self._get_adapter_registry().adapt_to(
+            self, obj_key=obj_key, **kwargs
+        )
 
     @classmethod
     def register_adapter(cls, adapter: type[Adapter]):
@@ -988,7 +997,7 @@ class Pile(Element, Collective[E], Generic[E]):
     def adapt_from(cls, obj: Any, obj_key: str, /, **kwargs: Any):
         """Create from another format."""
         dict_ = cls._get_adapter_registry().adapt_from(
-            cls, obj, obj_key, **kwargs
+            cls, obj, obj_key=obj_key, **kwargs
         )
         if isinstance(dict_, list):
             dict_ = {"collections": dict_}
@@ -1000,11 +1009,31 @@ class Pile(Element, Collective[E], Generic[E]):
         **kwargs: Any,
     ) -> pd.DataFrame:
         """Convert to DataFrame."""
-        return self.adapt_to("pd_dataframe", columns=columns, **kwargs)
+        # For DataFrame, we need to pass a list of dicts
+        data = [item.to_dict() for item in self.collections.values()]
+
+        # Create wrapper objects for each item
+        class _ItemWrapper:
+            def __init__(self, data):
+                self._data = data
+
+            def model_dump(self):
+                return self._data
+
+        wrappers = [_ItemWrapper(d) for d in data]
+        df = self._get_adapter_registry().adapt_to(
+            wrappers, obj_key="pd.DataFrame", many=True, **kwargs
+        )
+
+        if columns:
+            return df[columns]
+        return df
 
     def to_csv_file(self, fp: str | Path, **kwargs: Any) -> None:
         """Save to CSV file."""
-        self.adapt_to(".csv", fp=fp, **kwargs)
+        # Convert to DataFrame first, then save as CSV
+        df = self.to_df()
+        df.to_csv(fp, index=False, **kwargs)
 
     def to_json_file(
         self,
@@ -1025,8 +1054,14 @@ class Pile(Element, Collective[E], Generic[E]):
             **kwargs: Additional arguments for json.dump() or DataFrame.to_json().
         """
         if use_pd:
-            return self.to_df().to_json(mode=mode, **kwargs)
-        return self.adapt_to(".json", fp=path_or_buf, mode=mode, many=many)
+            return self.to_df().to_json(path_or_buf, mode=mode, **kwargs)
+
+        # Get JSON string from adapter
+        json_str = self.adapt_to("json", many=many, **kwargs)
+
+        # Write to file
+        with open(path_or_buf, mode, encoding="utf-8") as f:
+            f.write(json_str)
 
 
 def pile(
@@ -1052,16 +1087,28 @@ def pile(
     """
 
     if df:
-        return Pile.adapt_from(df, "pd_dataframe", **kwargs)
+        return Pile.adapt_from(df, "pd.DataFrame", **kwargs)
 
     if fp:
         fp = Path(fp)
         if fp.suffix == ".csv":
-            return Pile.adapt_from(fp, ".csv", **kwargs)
+            # Read CSV to DataFrame first
+            df = pd.read_csv(fp, **kwargs)
+            return Pile.adapt_from(df, "pd.DataFrame")
         if fp.suffix == ".xlsx":
-            return Pile.adapt_from(fp, ".xlsx", **kwargs)
+            # Read Excel to DataFrame first
+            df = pd.read_excel(fp, **kwargs)
+            return Pile.adapt_from(df, "pd.DataFrame")
         if fp.suffix in [".json", ".jsonl"]:
-            return Pile.adapt_from(fp, ".json", **kwargs)
+            # Read JSON file
+            with open(fp, encoding="utf-8") as f:
+                data = json.load(f)
+            if isinstance(data, dict):
+                return Pile.from_dict(data)
+            elif isinstance(data, list):
+                return Pile.from_dict({"collections": data})
+            else:
+                raise ValueError(f"Invalid JSON data structure in {fp}")
 
     return Pile(
         collections,

lionagi/protocols/graph/node.py

@@ -6,26 +6,19 @@ import json
 from typing import Any, ClassVar
 
 from pydantic import field_validator
+from pydapter import AdapterRegistry
+from pydapter.adapters import JsonAdapter, TomlAdapter
+from pydapter.extras.pandas_ import SeriesAdapter
 
 from lionagi._class_registry import LION_CLASS_REGISTRY
-from lionagi.adapters.types import (
-    AdapterRegistry,
-    JsonAdapter,
-    JsonFileAdapter,
-    PandasSeriesAdapter,
-    TomlAdapter,
-    TomlFileAdapter,
-)
 
 from .._concepts import Relational
 from ..generic.element import Element
 
 NODE_DEFAULT_ADAPTERS = (
     JsonAdapter,
-    JsonFileAdapter,
-    PandasSeriesAdapter,
+    SeriesAdapter,
     TomlAdapter,
-    TomlFileAdapter,
 )
 
 
@@ -33,8 +26,9 @@ class NodeAdapterRegistry(AdapterRegistry):
     pass
 
 
+node_adapter_registry = NodeAdapterRegistry()
 for i in NODE_DEFAULT_ADAPTERS:
-    NodeAdapterRegistry.register(i)
+    node_adapter_registry.register(i)
 
 __all__ = ("Node",)
 
@@ -48,7 +42,7 @@ class Node(Element, Relational):
       - Automatic subclass registration
     """
 
-    _adapter_registry: ClassVar[AdapterRegistry] = NodeAdapterRegistry
+    _adapter_registry: ClassVar[AdapterRegistry] = node_adapter_registry
 
     content: Any = None
     embedding: list[float] | None = None
@@ -88,8 +82,24 @@ class Node(Element, Relational):
         """
         Convert this Node to another format using a registered adapter.
         """
+        # For JSON/TOML adapters, we need to pass the dict representation
+        if obj_key in ["json", "toml"]:
+            data = self.to_dict()
+
+            # Create a simple object that has model_dump method
+            class _Wrapper:
+                def __init__(self, data):
+                    self._data = data
+
+                def model_dump(self):
+                    return self._data
+
+            wrapper = _Wrapper(data)
+            return self._get_adapter_registry().adapt_to(
+                wrapper, obj_key=obj_key, many=many, **kwargs
+            )
         return self._get_adapter_registry().adapt_to(
-            self, obj_key, many=many, **kwargs
+            self, obj_key=obj_key, many=many, **kwargs
         )
 
     @classmethod
@@ -107,7 +117,7 @@ class Node(Element, Relational):
         auto-delegate to the correct subclass via from_dict.
         """
         result = cls._get_adapter_registry().adapt_from(
-            cls, obj, obj_key, many=many, **kwargs
+            cls, obj, obj_key=obj_key, many=many, **kwargs
         )
         # If adapter returned multiple items, choose the first or handle as needed.
         if isinstance(result, list):
@@ -124,9 +134,5 @@ class Node(Element, Relational):
     def register_adapter(cls, adapter: Any) -> None:
         cls._get_adapter_registry().register(adapter)
 
-    @classmethod
-    def list_adapters(cls) -> list[str]:
-        return cls._get_adapter_registry().list_adapters()
-
 
 # File: lionagi/protocols/graph/node.py

lionagi/version.py

@@ -1 +1 @@
-__version__ = "0.12.4"
+__version__ = "0.12.5"

{lionagi-0.12.4.dist-info → lionagi-0.12.5.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lionagi
-Version: 0.12.4
+Version: 0.12.5
 Summary: An Intelligence Operating System.
 Author-email: HaiyangLi <quantocean.li@gmail.com>, Liangbingyan Luo <llby_luo@outlook.com>
 License:            Apache License
@@ -223,10 +223,9 @@ Requires-Dist: aiocache>=0.12.0
 Requires-Dist: aiohttp>=3.12.0
 Requires-Dist: backoff>=2.2.1
 Requires-Dist: jinja2>=3.1.0
-Requires-Dist: pandas>=2.0.0
 Requires-Dist: pillow>=11.0.0
 Requires-Dist: pydantic-settings>=2.8.0
-Requires-Dist: pydantic>2.0.0
+Requires-Dist: pydapter[pandas]>=0.3.0
 Requires-Dist: python-dotenv>=1.1.0
 Requires-Dist: tiktoken>=0.8.0
 Requires-Dist: toml>=0.9.0

{lionagi-0.12.4.dist-info → lionagi-0.12.5.dist-info}/RECORD

@@ -6,17 +6,7 @@ lionagi/config.py,sha256=dAhDFKtaaSfn6WT9dwX9Vd4TWWs6-Su1FgYIrFgYcgc,3709
 lionagi/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 lionagi/settings.py,sha256=W52mM34E6jXF3GyqCFzVREKZrmnUqtZm_BVDsUiDI_s,1627
 lionagi/utils.py,sha256=uLTJKl7aTnFXV6ehA6zwiwEB7G2nQYKsO2pZ6mqFzUk,78908
-lionagi/version.py,sha256=DoMS9KOhsApLyuLYhLEsd5nmoLFQ_IvVkEs_jKRzFk8,23
-lionagi/adapters/__init__.py,sha256=FJBV1Fb7GR9mcRApEB9bNP3IRMQ9Qjg5aVTouZFyTBU,45
-lionagi/adapters/adapter.py,sha256=aW7s1OKAdxHd8HBv2UcThn-r2Q08EyArssNyFobMLuA,3357
-lionagi/adapters/json_adapter.py,sha256=EJj0Jev46ZhU3ZMnlYwyzN2rLxjLCVrMDpHkEuggBvk,4561
-lionagi/adapters/toml_adapter.py,sha256=XOx0Q41g9FoNVuGrce96ck3gxPo4G-3mwqSin5kGq9s,5441
-lionagi/adapters/types.py,sha256=CHfB39BSeyU11SDkXXkU_vzqy4v7kaR-2r0y6DYkhXc,660
-lionagi/adapters/pandas_/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-lionagi/adapters/pandas_/csv_adapter.py,sha256=HWie6Jlt8nR-EVJC_zmCFilaWszLNuk7EWUp8Xvr-H8,2358
-lionagi/adapters/pandas_/excel_adapter.py,sha256=ZqRT2xF93NLKNyMp16ePNzwUN3ntNkUy1dO3nbsrfak,2287
-lionagi/adapters/pandas_/pd_dataframe_adapter.py,sha256=ULGZVhK5aaOuTrmFq4x5SiuDScYetyYYUHeL8Hh13Eg,2279
-lionagi/adapters/pandas_/pd_series_adapter.py,sha256=TX3cqFtgEip8JqVqkjdJYOu4PQGpW1yYU6POhvz8Jeg,1388
+lionagi/version.py,sha256=QFQfu3CUVe9Ncr8kv3aaBY3oWrZmv8xboen_Uwy7eXU,23
 lionagi/fields/__init__.py,sha256=8oU7Vfk-fKiULFKqhM6VpJMqdZcVXPTM7twVfNDN_SQ,603
 lionagi/fields/action.py,sha256=iWSApCM77jS0Oc28lb7G601Etkp-yjx5U1hfI_FQgfA,5792
 lionagi/fields/base.py,sha256=5CJc7j8kTTWzXwpYzkSAFzx4BglABfx3AElIATKB7bg,3857
@@ -140,13 +130,13 @@ lionagi/protocols/generic/__init__.py,sha256=5y5joOZzfFWERl75auAcNcKC3lImVJ5ZZGv
 lionagi/protocols/generic/element.py,sha256=Eaij2YpTWsGk28Tqjazmjmc_tOnalH7_iGFZrL6QJb4,14420
 lionagi/protocols/generic/event.py,sha256=InjBd2K9aSYxgai1c20d4jaJOkEx5VGFfb7iZbiMiNA,5200
 lionagi/protocols/generic/log.py,sha256=vepclOaY3fdR1QgFDj9usOffsx9T-9PbgwXjTvm6twQ,7441
-lionagi/protocols/generic/pile.py,sha256=0nAfmCb_0RjiSQPvW6tkzuHUk9aPHFvCySlL-TkokFI,31803
+lionagi/protocols/generic/pile.py,sha256=L965LgVKhaxpEe_5dOwjYFZ1UAGeWmUtZ4Tf0MRznHw,33562
 lionagi/protocols/generic/processor.py,sha256=LTF9Enb-9jj5Wuy_jLanAhiesc5-Gm6WiSntZoAAm8w,10382
 lionagi/protocols/generic/progression.py,sha256=qlITq1qzV119iR5qR__fBAzV489S7d4t20E8uDRicEw,15189
 lionagi/protocols/graph/__init__.py,sha256=5y5joOZzfFWERl75auAcNcKC3lImVJ5ZZGvvHZUFCJM,112
 lionagi/protocols/graph/edge.py,sha256=lgxeceoazM4Jl2Un_owLpJOanqw2m4XPk3-dXGp1u8g,5229
 lionagi/protocols/graph/graph.py,sha256=ks3zJWdwycUW_3Q4dz3f_ZLYhOALpg76t5J3HEzDcy4,10237
-lionagi/protocols/graph/node.py,sha256=cklw0PJcWPmFW8jGaZGT5enJDEkqulxRHgdMjRDKCl4,3799
+lionagi/protocols/graph/node.py,sha256=_bQ9h_s_X6dVyV4pueEfiKiFapOkDL-HuH2MboUekYI,4250
 lionagi/protocols/mail/__init__.py,sha256=5y5joOZzfFWERl75auAcNcKC3lImVJ5ZZGvvHZUFCJM,112
 lionagi/protocols/mail/exchange.py,sha256=P1PcrFylIBeiQa8kox9H1qyJ4kjhUlbLiTUT8rs1OXg,7041
 lionagi/protocols/mail/mail.py,sha256=RB5CUft_4J85H9nM9g6aRXomTaqKwF5xVjJacPAhoa8,1356
@@ -207,7 +197,7 @@ lionagi/tools/types.py,sha256=XtJLY0m-Yi_ZLWhm0KycayvqMCZd--HxfQ0x9vFUYDE,230
 lionagi/tools/file/__init__.py,sha256=5y5joOZzfFWERl75auAcNcKC3lImVJ5ZZGvvHZUFCJM,112
 lionagi/tools/file/reader.py,sha256=0TdnfVGVCKuM58MmGM-NyVjhU9BFoitkNYEepdc0z_Y,9529
 lionagi/tools/memory/tools.py,sha256=zTGBenVsF8Wuh303kWntmQSGlAFKonHNdh5ePuQ26KE,15948
-lionagi-0.12.4.dist-info/METADATA,sha256=qWskGXtFjTqx7LFfsjeVdiFFSgV4CerJiJTrhyhaxgk,18980
-lionagi-0.12.4.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-lionagi-0.12.4.dist-info/licenses/LICENSE,sha256=VXFWsdoN5AAknBCgFqQNgPWYx7OPp-PFEP961zGdOjc,11288
-lionagi-0.12.4.dist-info/RECORD,,
+lionagi-0.12.5.dist-info/METADATA,sha256=0vHIkYR3nyKPKxuivRY8XjNiVBk0UP0KvEbY2cxscEY,18960
+lionagi-0.12.5.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+lionagi-0.12.5.dist-info/licenses/LICENSE,sha256=VXFWsdoN5AAknBCgFqQNgPWYx7OPp-PFEP961zGdOjc,11288
+lionagi-0.12.5.dist-info/RECORD,,

lionagi/adapters/__init__.py

@@ -1 +0,0 @@
-"""deprecated, will be removed in v0.13.0"""

lionagi/adapters/adapter.py

@@ -1,120 +0,0 @@
-# Copyright (c) 2023 - 2025, HaiyangLi <quantocean.li at gmail dot com>
-#
-# SPDX-License-Identifier: Apache-2.0
-
-"""
-Defines the `Adapter` protocol (a formal interface), along with the
-`AdapterRegistry` that maps string/file extensions or object keys to
-specific adapter implementations.
-"""
-
-import logging
-from typing import Any, Protocol, TypeVar, runtime_checkable
-
-from typing_extensions import get_protocol_members
-
-T = TypeVar("T")
-
-__all__ = (
-    "Adapter",
-    "ADAPTER_MEMBERS",
-    "AdapterRegistry",
-)
-
-
-@runtime_checkable
-class Adapter(Protocol):
-    """
-    Describes a two-way converter that knows how to transform an object
-    from an external representation to an internal format, and vice versa.
-
-    Attributes
-    ----------
-    obj_key : str
-        A unique key or extension that identifies what format this
-        adapter supports (e.g. ".csv", "json", "pd_dataframe").
-
-    Methods
-    -------
-    from_obj(subj_cls: type[T], obj: Any, /, many: bool, **kwargs) -> dict|list[dict]
-        Converts a raw external object (file contents, JSON string, etc.)
-        into a dictionary or list of dictionaries.
-    to_obj(subj: T, /, many: bool, **kwargs) -> Any
-        Converts an internal object (e.g., a Pydantic-based model)
-        into the target format (file, JSON, DataFrame, etc.).
-    """
-
-    obj_key: str
-
-    @classmethod
-    def from_obj(
-        cls,
-        subj_cls: type[T],
-        obj: Any,
-        /,
-        *,
-        many: bool,
-        **kwargs,
-    ) -> dict | list[dict]: ...
-
-    @classmethod
-    def to_obj(
-        cls,
-        subj: T,
-        /,
-        *,
-        many: bool,
-        **kwargs,
-    ) -> Any: ...
-
-
-ADAPTER_MEMBERS = get_protocol_members(Adapter)  # duck typing
-
-
-class AdapterRegistry:
-
-    _adapters: dict[str, Adapter] = {}
-
-    @classmethod
-    def list_adapters(cls) -> list[tuple[str | type, ...]]:
-        return list(cls._adapters.keys())
-
-    @classmethod
-    def register(cls, adapter: type[Adapter]) -> None:
-        for member in ADAPTER_MEMBERS:
-            if not hasattr(adapter, member):
-                _str = getattr(adapter, "obj_key", None) or repr(adapter)
-                _str = _str[:50] if len(_str) > 50 else _str
-                raise AttributeError(
-                    f"Adapter {_str} missing required methods."
-                )
-
-        if isinstance(adapter, type):
-            cls._adapters[adapter.obj_key] = adapter()
-        else:
-            cls._adapters[adapter.obj_key] = adapter
-
-    @classmethod
-    def get(cls, obj_key: type | str) -> Adapter:
-        try:
-            return cls._adapters[obj_key]
-        except Exception as e:
-            logging.error(f"Error getting adapter for {obj_key}. Error: {e}")
-
-    @classmethod
-    def adapt_from(
-        cls, subj_cls: type[T], obj: Any, obj_key: type | str, **kwargs
-    ) -> dict | list[dict]:
-        try:
-            return cls.get(obj_key).from_obj(subj_cls, obj, **kwargs)
-        except Exception as e:
-            logging.error(f"Error adapting data from {obj_key}. Error: {e}")
-            raise e
-
-    @classmethod
-    def adapt_to(cls, subj: T, obj_key: type | str, **kwargs) -> Any:
-        try:
-            return cls.get(obj_key).to_obj(subj, **kwargs)
-        except Exception as e:
-            logging.error(f"Error adapting data to {obj_key}. Error: {e}")
-            raise e

lionagi/adapters/json_adapter.py

@@ -1,181 +0,0 @@
-"""
-Implements two adapters:
-- `JsonAdapter` for in-memory JSON strings
-- `JsonFileAdapter` for reading/writing JSON files
-"""
-
-import json
-import logging
-from pathlib import Path
-
-from lionagi.protocols._concepts import Collective
-
-from .adapter import Adapter, T
-
-
-class JsonAdapter(Adapter):
-    """
-    Adapter that converts to/from JSON **strings** in memory.
-    Example usage: taking a Python dictionary and making JSON,
-    or parsing JSON string to a dict.
-    """
-
-    obj_key = "json"
-
-    @classmethod
-    def from_obj(
-        cls,
-        subj_cls: type[T],
-        obj: str,
-        /,
-        *,
-        many: bool = False,
-        **kwargs,
-    ) -> dict | list[dict]:
-        """
-        Convert a JSON string into a dict or list of dicts.
-
-        Parameters
-        ----------
-        subj_cls : type[T]
-            The target class for context (not always used).
-        obj : str
-            The JSON string.
-        many : bool, optional
-            If True, expects a JSON array (returns list[dict]).
-            Otherwise returns a single dict or the first element.
-        **kwargs
-            Extra arguments for json.loads().
-
-        Returns
-        -------
-        dict | list[dict]
-            The loaded JSON data.
-        """
-        result = json.loads(obj, **kwargs)
-        if many:
-            return result if isinstance(result, list) else [result]
-        if isinstance(result, list) and len(result) > 0:
-            return result[0]
-        return result
-
-    @classmethod
-    def to_obj(
-        cls,
-        subj: T,
-        *,
-        many: bool = False,
-        **kwargs,
-    ) -> str:
-        """
-        Convert an object (or collection) to a JSON string.
-
-        Parameters
-        ----------
-        subj : T
-            The object to serialize.
-        many : bool, optional
-            If True, convert multiple items to a JSON array.
-        **kwargs
-            Extra arguments for json.dumps().
-
-        Returns
-        -------
-        str
-            The resulting JSON string.
-        """
-        if many:
-            if isinstance(subj, Collective):
-                data = [i.to_dict() for i in subj]
-            else:
-                data = [subj.to_dict()]
-            return json.dumps(data, **kwargs)
-        return json.dumps(subj.to_dict(), **kwargs)
-
-
-class JsonFileAdapter(Adapter):
-    """
-    Adapter that reads/writes JSON data to/from a file on disk.
-    The file extension key is ".json".
-    """
-
-    obj_key = ".json"
-
-    @classmethod
-    def from_obj(
-        cls,
-        subj_cls: type[T],
-        obj: str | Path,
-        /,
-        *,
-        many: bool = False,
-        **kwargs,
-    ) -> dict | list[dict]:
-        """
-        Read a JSON 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 JSON file path.
-        many : bool
-            If True, expects a list. Otherwise single dict or first element.
-        **kwargs
-            Extra arguments for json.load().
-
-        Returns
-        -------
-        dict | list[dict]
-            The loaded data from file.
-        """
-        with open(obj, encoding="utf-8") as f:
-            result = json.load(f, **kwargs)
-        if many:
-            return result if isinstance(result, list) else [result]
-        if isinstance(result, list) and len(result) > 0:
-            return result[0]
-        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 JSON file.
-
-        Parameters
-        ----------
-        subj : T
-            The object/collection to serialize.
-        fp : str | Path
-            The file path to write.
-        many : bool
-            If True, write as a JSON array of multiple items.
-        **kwargs
-            Extra arguments for json.dump().
-
-        Returns
-        -------
-        None
-        """
-        with open(fp, mode, encoding="utf-8") as f:
-            if many:
-                if isinstance(subj, Collective):
-                    json.dump([i.to_dict() for i in subj], f, **kwargs)
-                else:
-                    json.dump([subj.to_dict()], f, **kwargs)
-            else:
-                json.dump(subj.to_dict(), f, **kwargs)
-        logging.info(f"JSON data saved to {fp}")
-
-
-# File: lionagi/protocols/adapters/json_adapter.py

lionagi/adapters/pandas_/csv_adapter.py

@@ -1,94 +0,0 @@
-import logging
-from pathlib import Path
-
-import pandas as pd
-
-from lionagi.protocols._concepts import Collective
-
-from ..adapter import Adapter, T
-
-
-class CSVFileAdapter(Adapter):
-    """
-    Reads/writes CSV files to a list of dicts or vice versa,
-    using `pandas`.
-    """
-
-    obj_key = ".csv"
-
-    @classmethod
-    def from_obj(
-        cls,
-        subj_cls: type[T],
-        obj: str | Path,
-        /,
-        *,
-        many: bool = False,
-        **kwargs,
-    ) -> list[dict]:
-        """
-        Read a CSV file into a list of dictionaries.
-
-        Parameters
-        ----------
-        subj_cls : type[T]
-            The target class for context (not used).
-        obj : str | Path
-            The CSV file path.
-        many : bool, optional
-            If True, returns list[dict]; if False, returns only
-            the first dict.
-        **kwargs
-            Additional options for `pd.read_csv`.
-
-        Returns
-        -------
-        list[dict]
-            The parsed CSV data as a list of row dictionaries.
-        """
-        df: pd.DataFrame = pd.read_csv(obj, **kwargs)
-        dicts_ = df.to_dict(orient="records")
-        if many:
-            return dicts_
-        return dicts_[0] if len(dicts_) > 0 else {}
-
-    @classmethod
-    def to_obj(
-        cls,
-        subj: T,
-        /,
-        *,
-        fp: str | Path,
-        many: bool = False,
-        **kwargs,
-    ) -> None:
-        """
-        Write an object's data to a CSV file.
-
-        Parameters
-        ----------
-        subj : T
-            The item(s) to convert. If `many=True`, can be a Collective.
-        fp : str | Path
-            File path to write the CSV.
-        many : bool
-            If True, we assume a collection of items, else a single item.
-        **kwargs
-            Extra params for `DataFrame.to_csv`.
-
-        Returns
-        -------
-        None
-        """
-        kwargs["index"] = False  # By default, do not save index
-        if many:
-            if isinstance(subj, Collective):
-                pd.DataFrame([i.to_dict() for i in subj]).to_csv(fp, **kwargs)
-            else:
-                pd.DataFrame([subj.to_dict()]).to_csv(fp, **kwargs)
-        else:
-            pd.DataFrame([subj.to_dict()]).to_csv(fp, **kwargs)
-        logging.info(f"CSV data saved to {fp}")
-
-
-# File: lionagi/protocols/adapters/pandas_/csv_adapter.py

lionagi/adapters/pandas_/excel_adapter.py

@@ -1,94 +0,0 @@
-"""
-Provides an ExcelFileAdapter for reading/writing Excel (.xlsx) files
-via pandas.
-"""
-
-import logging
-from pathlib import Path
-
-import pandas as pd
-
-from lionagi.protocols._concepts import Collective
-
-from ..adapter import Adapter, T
-
-
-class ExcelFileAdapter(Adapter):
-    """
-    Reads/writes Excel (XLSX) files, using `pandas`.
-    """
-
-    obj_key = ".xlsx"
-
-    @classmethod
-    def from_obj(
-        cls,
-        subj_cls: type[T],
-        obj: str | Path,
-        /,
-        *,
-        many: bool = False,
-        **kwargs,
-    ) -> list[dict]:
-        """
-        Read an Excel file into a list of dictionaries.
-
-        Parameters
-        ----------
-        subj_cls : type[T]
-            Target class for context.
-        obj : str | Path
-            The Excel file path.
-        many : bool, optional
-            If True, returns list[dict]. If False, returns single dict or first element.
-        **kwargs
-            Additional options for `pd.read_excel`.
-
-        Returns
-        -------
-        list[dict]
-        """
-        df: pd.DataFrame = pd.read_excel(obj, **kwargs)
-        dicts_ = df.to_dict(orient="records")
-        if many:
-            return dicts_
-        return dicts_[0] if len(dicts_) > 0 else {}
-
-    @classmethod
-    def to_obj(
-        cls,
-        subj: T,
-        /,
-        *,
-        fp: str | Path,
-        many: bool = False,
-        **kwargs,
-    ) -> None:
-        """
-        Write data to an Excel file.
-
-        Parameters
-        ----------
-        subj : T
-            The object(s) to convert to Excel rows.
-        fp : str | Path
-            Path to save the XLSX file.
-        many : bool
-            If True, writes multiple items (e.g., a Collective).
-        **kwargs
-            Extra parameters for `DataFrame.to_excel`.
-        """
-        kwargs["index"] = False
-        if many:
-            if isinstance(subj, Collective):
-                pd.DataFrame([i.to_dict() for i in subj]).to_excel(
-                    fp, **kwargs
-                )
-            else:
-                pd.DataFrame([subj.to_dict()]).to_excel(fp, **kwargs)
-        else:
-            pd.DataFrame([subj.to_dict()]).to_excel(fp, **kwargs)
-        logging.info(f"Excel data saved to {fp}")
-
-
-# File: lionagi/protocols/adapters/pandas_/excel_adapter.py

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",
-)