lionagi 0.5.5__py3-none-any.whl → 0.6.1__py3-none-any.whl

lionagi/protocols/_concepts.py

@@ -0,0 +1,94 @@
+# Copyright (c) 2023 - 2024, HaiyangLi <quantocean.li at gmail dot com>
+#
+# SPDX-License-Identifier: Apache-2.0
+
+from abc import ABC, abstractmethod
+from typing import Generic, TypeVar
+
+E = TypeVar("E")
+
+
+__all__ = (
+    "Observer",
+    "Manager",
+    "Relational",
+    "Sendable",
+    "Observable",
+    "Communicatable",
+    "Condition",
+    "Collective",
+    "Ordering",
+)
+
+
+class Observer(ABC):
+    """Base for all observers."""
+
+    pass
+
+
+class Manager(Observer):
+    """Base for all managers."""
+
+    pass
+
+
+class Relational(ABC):
+    """Base for graph-connectable objects."""
+
+    pass
+
+
+class Sendable(ABC):
+    """Sendable entities must define 'sender' and 'recipient'."""
+
+    pass
+
+
+class Observable(ABC):
+    """Observable entities must define 'id'."""
+
+    pass
+
+
+class Communicatable(Observable):
+    """Communicatable must define 'mailbox' and send/receive methods."""
+
+    @abstractmethod
+    def send(self, *args, **kwargs):
+        pass
+
+
+class Condition(ABC):
+    """Base for conditions."""
+
+    @abstractmethod
+    async def apply(self, *args, **kwargs) -> bool:
+        pass
+
+
+class Collective(ABC, Generic[E]):
+    """Base for collections of elements."""
+
+    @abstractmethod
+    def include(self, item, /):
+        pass
+
+    @abstractmethod
+    def exclude(self, item, /):
+        pass
+
+
+class Ordering(ABC, Generic[E]):
+    """Base for element orderings."""
+
+    @abstractmethod
+    def include(self, item, /):
+        pass
+
+    @abstractmethod
+    def exclude(self, item, /):
+        pass
+
+
+# File: protocols/generic/concepts.py

lionagi/protocols/adapters/adapter.py

@@ -9,6 +9,12 @@ from typing_extensions import get_protocol_members
 
 T = TypeVar("T")
 
+__all__ = (
+    "Adapter",
+    "ADAPTER_MEMBERS",
+    "AdapterRegistry",
+)
+
 
 @runtime_checkable
 class Adapter(Protocol):
@@ -17,14 +23,27 @@ class Adapter(Protocol):
 
     @classmethod
     def from_obj(
-        cls, subj_cls: type[T], obj: Any, /, **kwargs
+        cls,
+        subj_cls: type[T],
+        obj: Any,
+        /,
+        *,
+        many: bool,
+        **kwargs,
     ) -> dict | list[dict]: ...
 
     @classmethod
-    def to_obj(cls, subj: T, /, **kwargs) -> Any: ...
+    def to_obj(
+        cls,
+        subj: T,
+        /,
+        *,
+        many: bool,
+        **kwargs,
+    ) -> Any: ...
 
 
-adapter_members = get_protocol_members(Adapter)  # duck typing
+ADAPTER_MEMBERS = get_protocol_members(Adapter)  # duck typing
 
 
 class AdapterRegistry:
@@ -37,7 +56,7 @@ class AdapterRegistry:
 
     @classmethod
     def register(cls, adapter: type[Adapter]) -> None:
-        for member in adapter_members:
+        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
@@ -74,6 +93,3 @@ class AdapterRegistry:
         except Exception as e:
             logging.error(f"Error adapting data to {obj_key}. Error: {e}")
             raise e
-
-
-__all__ = ["AdapterRegistry", "Adapter"]

lionagi/protocols/adapters/json_adapter.py

@@ -1,12 +1,10 @@
-# Copyright (c) 2023 - 2024, HaiyangLi <quantocean.li at gmail dot com>
-#
-# SPDX-License-Identifier: Apache-2.0
-
 import json
 import logging
 from pathlib import Path
 
-from lionagi.protocols.adapters.adapter import Adapter, T
+from lionagi.protocols._concepts import Collective
+
+from .adapter import Adapter, T
 
 
 class JsonAdapter(Adapter):
@@ -14,12 +12,43 @@ class JsonAdapter(Adapter):
     obj_key = "json"
 
     @classmethod
-    def from_obj(cls, subj_cls: type[T], obj: str, /) -> dict:
-        return json.loads(obj)
+    def from_obj(
+        cls,
+        subj_cls: type[T],
+        obj: str,
+        /,
+        *,
+        many: bool = False,
+        **kwargs,
+    ) -> dict | list[dict]:
+        """
+        kwargs for json.loads(s, **kwargs)
+        """
+        result = json.loads(obj, **kwargs)
+        if many:
+            return result if isinstance(result, list) else [result]
+        return (
+            result[0]
+            if isinstance(result, list) and len(result) > 0
+            else result
+        )
 
     @classmethod
-    def to_obj(cls, subj: T) -> str:
-        return json.dumps(subj.to_dict())
+    def to_obj(
+        cls,
+        subj: T,
+        *,
+        many: bool = False,
+        **kwargs,
+    ):
+        """
+        kwargs for json.dumps(obj, **kwargs)
+        """
+        if many:
+            if isinstance(subj, Collective):
+                return json.dumps([i.to_dict() for i in subj], **kwargs)
+            return json.dumps([subj.to_dict()], **kwargs)
+        return json.dumps(subj.to_dict(), **kwargs)
 
 
 class JsonFileAdapter(Adapter):
@@ -27,17 +56,46 @@ class JsonFileAdapter(Adapter):
     obj_key = ".json"
 
     @classmethod
-    def from_obj(cls, subj_cls: type[T], obj: str | Path, /) -> dict:
+    def from_obj(
+        cls,
+        subj_cls: type[T],
+        obj: str | Path,
+        /,
+        *,
+        many: bool = False,
+        **kwargs,
+    ) -> dict | list[dict]:
+        """
+        kwargs for json.load(fp, **kwargs)
+        """
         with open(obj) as f:
-            return json.load(f)
+            result = json.load(f, **kwargs)
+        if many:
+            return result if isinstance(result, list) else [result]
+        return (
+            result[0]
+            if isinstance(result, list) and len(result) > 0
+            else result
+        )
 
     @classmethod
     def to_obj(
         cls,
         subj: T,
         /,
+        *,
         fp: str | Path,
-    ) -> None:
-        with open(fp, "w") as f:
-            json.dump(subj.to_dict(), f)
+        many: bool = False,
+        **kwargs,
+    ):
+        """
+        kwargs for json.dump(obj, fp, **kwargs)
+        """
+        if many:
+            if isinstance(subj, Collective):
+                json.dump([i.to_dict() for i in subj], fp=fp, **kwargs)
+                return
+            json.dump([subj.to_dict()], fp=fp, **kwargs)
+            return
+        json.dump(subj.to_dict(), fp=fp, **kwargs)
         logging.info(f"Successfully saved data to {fp}")

lionagi/protocols/adapters/pandas_/csv_adapter.py

@@ -0,0 +1,50 @@
+import logging
+from pathlib import Path
+
+import pandas as pd
+
+from lionagi.protocols._concepts import Collective
+
+from ..adapter import Adapter, T
+
+
+class CSVFileAdapter(Adapter):
+    obj_key = ".csv"
+
+    @classmethod
+    def from_obj(
+        cls,
+        subj_cls: type[T],
+        obj: str | Path,
+        /,
+        *,
+        many: bool = False,
+        **kwargs,
+    ) -> list[dict]:
+        """kwargs for pd.read_csv"""
+        df: pd.DataFrame = pd.read_csv(obj, **kwargs)
+        dicts_ = df.to_dict(orient="records")
+        return dicts_[0] if not many else dicts_
+
+    @classmethod
+    def to_obj(
+        cls,
+        subj: T,
+        /,
+        *,
+        fp: str | Path,
+        many: bool = False,
+        **kwargs,
+    ):
+        """kwargs for pd.DataFrame.to_csv"""
+        kwargs["index"] = False
+        if many:
+            if isinstance(subj, Collective):
+                pd.DataFrame([i.to_dict() for i in subj]).to_csv(fp, **kwargs)
+                logging.info(f"Successfully saved data to {fp}")
+                return
+            pd.DataFrame([subj.to_dict()]).to_csv(fp, **kwargs)
+            logging.info(f"Successfully saved data to {fp}")
+            return
+        pd.DataFrame([subj.to_dict()]).to_csv(fp, **kwargs)
+        logging.info(f"Successfully saved data to {fp}")

lionagi/protocols/adapters/pandas_/excel_adapter.py

@@ -0,0 +1,52 @@
+import logging
+from pathlib import Path
+
+import pandas as pd
+
+from lionagi.protocols._concepts import Collective
+
+from ..adapter import Adapter, T
+
+
+class ExcelFileAdapter(Adapter):
+    obj_key = ".xlsx"
+
+    @classmethod
+    def from_obj(
+        cls,
+        subj_cls: type[T],
+        obj: str | Path,
+        /,
+        *,
+        many: bool = False,
+        **kwargs,
+    ) -> list[dict]:
+        """kwargs for pd.read_csv"""
+        df: pd.DataFrame = pd.read_excel(obj, **kwargs)
+        dicts_ = df.to_dict(orient="records")
+        return dicts_[0] if not many else dicts_
+
+    @classmethod
+    def to_obj(
+        cls,
+        subj: T,
+        /,
+        *,
+        fp: str | Path,
+        many: bool = False,
+        **kwargs,
+    ):
+        """kwargs for pd.DataFrame.to_csv"""
+        kwargs["index"] = False
+        if many:
+            if isinstance(subj, Collective):
+                pd.DataFrame([i.to_dict() for i in subj]).to_excel(
+                    fp, **kwargs
+                )
+                logging.info(f"Successfully saved data to {fp}")
+                return
+            pd.DataFrame([subj.to_dict()]).to_excel(fp, **kwargs)
+            logging.info(f"Successfully saved data to {fp}")
+            return
+        pd.DataFrame([subj.to_dict()]).to_excel(fp, **kwargs)
+        logging.info(f"Successfully saved data to {fp}")

lionagi/protocols/adapters/pandas_/pd_dataframe_adapter.py

@@ -0,0 +1,31 @@
+from datetime import datetime
+
+import pandas as pd
+
+from ..adapter import Adapter, T
+
+
+class PandasDataFrameAdapter(Adapter):
+
+    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]:
+        """kwargs for pd.DataFrame.to_dict"""
+        return obj.to_dict(orient="records", **kwargs)
+
+    @classmethod
+    def to_obj(cls, subj: list[T], /, **kwargs) -> pd.DataFrame:
+        """kwargs for pd.DataFrame"""
+        out_ = []
+        for i in subj:
+            _dict = i.to_dict()
+            _dict["created_at"] = datetime.fromtimestamp(_dict["created_at"])
+            out_.append(_dict)
+        df = pd.DataFrame(out_, **kwargs)
+        if "created_at" in df.columns:
+            df["created_at"] = pd.to_datetime(df["created_at"])
+        return df

lionagi/protocols/adapters/pandas_/pd_series_adapter.py

@@ -0,0 +1,17 @@
+import pandas as pd
+
+from ..adapter import Adapter, T
+
+
+class PandasSeriesAdapter(Adapter):
+
+    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:
+        return obj.to_dict(**kwargs)
+
+    @classmethod
+    def to_obj(cls, subj: T, /, **kwargs) -> pd.Series:
+        return pd.Series(subj.to_dict(), **kwargs)

lionagi/protocols/adapters/types.py

@@ -0,0 +1,18 @@
+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
+
+__all__ = (
+    "Adapter",
+    "AdapterRegistry",
+    "ADAPTER_MEMBERS",
+    "JsonAdapter",
+    "JsonFileAdapter",
+    "CSVFileAdapter",
+    "PandasSeriesAdapter",
+    "PandasDataFrameAdapter",
+    "ExcelFileAdapter",
+)