agently 4.0.6.3__tar.gz → 4.0.6.5__tar.gz

{agently-4.0.6.3 → agently-4.0.6.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: agently
-Version: 4.0.6.3
+Version: 4.0.6.5
 Summary: 
 License: Apache-2.0
 License-File: LICENSE

{agently-4.0.6.3 → agently-4.0.6.5}/agently/builtins/plugins/ModelRequester/OpenAICompatible.py

@@ -391,7 +391,9 @@ class OpenAICompatible(ModelRequester):
                     # Raise status code >= 400
                     if response.status_code >= 400:
                         e = RequestError(
-                            f"Status Code: { response.status_code }\n" f"Request Data: {full_request_data}"
+                            f"Status Code: { response.status_code }\n"
+                            f"Detail: { response.text }\n"
+                            f"Request Data: {full_request_data}"
                         )
                         self._messenger.error(
                             e,
@@ -461,7 +463,9 @@ class OpenAICompatible(ModelRequester):
                     )
                     if response.status_code >= 400:
                         e = RequestError(
-                            f"Status Code: { response.status_code }\n" f"Request Data: {full_request_data}"
+                            f"Status Code: { response.status_code }\n"
+                            f"Detail: { response.text }\n"
+                            f"Request Data: {full_request_data}"
                         )
                         self._messenger.error(
                             e,

agently-4.0.6.5/agently/integrations/chromadb.py

@@ -0,0 +1,167 @@
+from agently.utils import LazyImport, FunctionShifter
+
+LazyImport.import_package("chromadb")
+
+from typing import Callable, TypedDict, Any, TYPE_CHECKING
+
+from chromadb.api.types import EmbeddingFunction, DefaultEmbeddingFunction
+
+if TYPE_CHECKING:
+    from chromadb.api.types import (
+        Documents,
+        Embedding,
+        Embeddings,
+        QueryResult,
+        Schema,
+        CollectionMetadata,
+        DataLoader,
+        Loadable,
+    )
+    from chromadb.api.collection_configuration import CreateCollectionConfiguration
+    from chromadb.api import ClientAPI
+    from agently.core import BaseAgent
+
+
+class ChromaDataDictOptional(TypedDict, total=False):
+    metadata: dict[Any, Any]
+    id: Any
+    embedding: "Embedding"
+
+
+class ChromaDataDict(ChromaDataDictOptional):
+    document: str
+
+
+class ChromaData:
+    def __init__(
+        self,
+        original_data: ChromaDataDict | list[ChromaDataDict],
+        *,
+        embedding_function: "Callable[[str | list[str]], Embeddings] | None" = None,
+        agent: "BaseAgent | None" = None,
+    ):
+        self._original_data = original_data if isinstance(original_data, list) else [original_data]
+        if embedding_function:
+            self._embedding_function = embedding_function
+        elif agent:
+
+            def embedding_function_by_agent(texts: str | list[str]) -> "Embeddings":
+                return agent.input(texts).start()
+
+            self._embedding_function = embedding_function_by_agent
+        else:
+            self._embedding_function = None
+        self._chroma_data = {
+            "documents": [],
+            "metadatas": [],
+            "ids": [],
+            "embeddings": [],
+        }
+        if self._embedding_function is not None:
+            documents = [data["document"] for data in self._original_data]
+            embeddings = self._embedding_function(documents)
+            self._chroma_data["embeddings"] = embeddings
+            for index, data in enumerate(self._original_data):
+                data["embedding"] = embeddings[index]
+        else:
+            del self._chroma_data["embeddings"]
+        for index, data in enumerate(self._original_data):
+            self._chroma_data["documents"].append(data["document"])
+            self._chroma_data["metadatas"].append(data["metadata"] if "metadata" in data else None)
+            self._chroma_data["ids"].append(data["id"] if "id" in data else str(index))
+
+    def get_kwargs(self):
+        return self._chroma_data
+
+    def get_original_data(self):
+        return self._original_data
+
+
+class ChromaResults:
+    def __init__(
+        self,
+        *,
+        queries: str | list[str],
+        results: "QueryResult",
+    ):
+        if isinstance(queries, str):
+            queries = [queries]
+        if len(queries) != len(results["documents"] or []):
+            raise ValueError(
+                f"The length of queries does not equal the length of results.\nQueries: { queries }\nResults: { results }"
+            )
+        self._chroma_results = results
+        self._results = {}
+        for query_index, query in enumerate(queries):
+            for result_index, id in enumerate(results["ids"][query_index]):
+                result = {
+                    "id": id,
+                    "document": results["documents"][query_index][result_index] if results["documents"] else None,
+                    "metadata": results["metadatas"][query_index][result_index] if results["metadatas"] else None,
+                    "distance": results["distances"][query_index][result_index] if results["distances"] else None,
+                }
+                self._results[query] = result
+
+    def get_original_results(self):
+        return self._chroma_results
+
+    def get(self):
+        return self._results
+
+
+class ChromaEmbeddingFunction(EmbeddingFunction):
+    def __init__(
+        self,
+        *,
+        embedding_function: "Callable[[list[str]], Embeddings] | None" = None,
+        agent: "BaseAgent | None" = None,
+    ):
+        if embedding_function:
+            self.embedding_function = embedding_function
+        elif agent:
+
+            def embedding_function_by_agent(texts: list[str]) -> "Embeddings":
+                return agent.input(texts).start()
+
+            self.embedding_function = embedding_function_by_agent
+        else:
+            raise ValueError(
+                f"ChromaEmbeddingFunction() requires at least one definition for 'embedding_function' or 'agent'."
+            )
+
+    def __call__(self, documents: "Documents") -> "Embeddings":
+        return self.embedding_function([document for document in documents])
+
+
+class ChromaCollection:
+    def __init__(
+        self,
+        conn: "ClientAPI",
+        collection_name: str,
+        *,
+        schema: "Schema | None" = None,
+        configuration: "CreateCollectionConfiguration | None" = None,
+        metadata: None = None,
+        embedding_function: EmbeddingFunction | None = None,
+        agent: "BaseAgent | None" = None,
+        data_loader: "DataLoader[Loadable] | None" = None,
+        get_or_create: bool = False,
+    ):
+        if embedding_function:
+            self._embedding_function = embedding_function
+        elif agent:
+            self._embedding_function = ChromaEmbeddingFunction(agent=agent)
+        else:
+            self._embedding_function = DefaultEmbeddingFunction()
+
+        self._collection = conn.create_collection(
+            collection_name,
+            schema=schema,
+            configuration=configuration,
+            metadata=metadata,
+            embedding_function=embedding_function,
+            data_loader=data_loader,
+            get_or_create=get_or_create,
+        )
+
+    def add(self): ...

{agently-4.0.6.3 → agently-4.0.6.5}/agently/types/data/tool.py

@@ -13,12 +13,12 @@
 # limitations under the License.
 
 
-from typing import Literal, Callable, TypeAlias
+from typing import Any, Literal, Callable, TypeAlias
 from typing_extensions import TypedDict, NotRequired
 from pydantic import AnyUrl
 from httpx import Auth, AsyncClient
 
-ArgumentDesc: TypeAlias = type | str | tuple[str | type, str]
+ArgumentDesc: TypeAlias = type | str | tuple[str | type | Any, str]
 KwargsType: TypeAlias = dict[str, ArgumentDesc]
 ReturnType: TypeAlias = KwargsType | ArgumentDesc | dict[str, "ReturnType"] | list["ReturnType"]
 

{agently-4.0.6.3 → agently-4.0.6.5}/agently/utils/DataFormatter.py

@@ -218,21 +218,31 @@ class DataFormatter:
                 raise KeyError(f"Cannot find key 'type' in input schema: { input_schema }")
             if input_schema["type"] != "object":
                 raise TypeError(f"Input schema type is not 'object' but: { input_schema['type'] }")
-            if "properties" not in input_schema:
-                raise KeyError(f"Cannot find key 'properties' in input schema: { input_schema }")
-            properties = input_schema["properties"]
+
             kwargs_format: "KwargsType" = {}
-            for kwarg_name, kwarg_schema in properties.items():
-                if "type" in kwarg_schema:
-                    kwarg_type = kwarg_schema["type"]
-                    del kwarg_schema["type"]
+
+            if "properties" in input_schema and input_schema["properties"]:
+                properties = input_schema["properties"]
+                for kwarg_name, kwarg_schema in properties.items():
+                    kwarg_type = kwarg_schema.pop("type", Any)
+                    kwarg_schema.pop("title", None)
+                    kwarg_desc = ";".join([f"{k}: {v}" for k, v in kwarg_schema.items()]) if kwarg_schema else ""
+                    kwargs_format[kwarg_name] = (kwarg_type, kwarg_desc)
+
+            if "additionalProperties" in input_schema:
+                additional_properties = input_schema["additionalProperties"]
+                if additional_properties is True or additional_properties is None:
+                    kwargs_format["<*>"] = (Any, "")
                 else:
-                    kwarg_type = any
-                if "title" in kwarg_schema:
-                    del kwarg_schema["title"]
-                kwarg_desc = None
-                if kwarg_schema.keys():
-                    kwarg_desc = ";".join([f"{ key }: { value }" for key, value in kwarg_schema.items()])
-                kwargs_format.update({kwarg_name: (kwarg_type, kwarg_desc)})
-            return kwargs_format if len(kwargs_format.keys()) > 0 else None
+                    additional_type = additional_properties.pop("type", Any)
+                    additional_properties.pop("title", None)
+                    additional_desc = (
+                        ";".join([f"{k}: {v}" for k, v in additional_properties.items()])
+                        if additional_properties
+                        else ""
+                    )
+                    kwargs_format["<*>"] = (additional_type, additional_desc)
+
+            return kwargs_format or None
+
         return None

{agently-4.0.6.3 → agently-4.0.6.5}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "agently"
-version = "4.0.6.3"
+version = "4.0.6.5"
 description = ""
 authors = [
     {name = "Agently Team",email = "developer@agently.tech"},

agently-4.0.6.3/agently/integrations/chromadb.py

@@ -1,86 +0,0 @@
-from agently.utils import LazyImport
-
-LazyImport.import_package("chromadb")
-
-import json
-
-from chromadb.api.types import EmbeddingFunction, Documents, Embedding, Embeddings
-
-from typing import Callable, TypedDict, Any, cast
-from agently.core import BaseAgent
-
-
-class ChromaDataDictOptional(TypedDict, total=False):
-    metadata: dict[Any, Any]
-    id: Any
-    embedding: Embedding
-
-
-class ChromaDataDict(ChromaDataDictOptional):
-    document: str
-
-
-class ChromaData:
-    def __init__(
-        self,
-        original_data: ChromaDataDict | list[ChromaDataDict],
-        *,
-        embedding_function: Callable[[str | list[str]], Embeddings] | None = None,
-        agent: BaseAgent | None = None,
-    ):
-        self._original_data = original_data if isinstance(original_data, list) else [original_data]
-        if embedding_function:
-            self._embedding_function = embedding_function
-        elif agent:
-
-            def embedding_function_by_agent(texts: str | list[str]) -> Embeddings:
-                return agent.input(texts).start()
-
-            self._embedding_function = embedding_function_by_agent
-        else:
-            self._embedding_function = None
-        self._chroma_data = {
-            "documents": [],
-            "metadatas": [],
-            "ids": [],
-            "embeddings": [],
-        }
-        if self._embedding_function is not None:
-            documents = [data["document"] for data in self._original_data]
-            embeddings = self._embedding_function(documents)
-            self._chroma_data["embeddings"] = embeddings
-            for index, data in enumerate(self._original_data):
-                data["embedding"] = embeddings[index]
-        else:
-            del self._chroma_data["embeddings"]
-        for index, data in enumerate(self._original_data):
-            self._chroma_data["documents"].append(data["document"])
-            self._chroma_data["metadatas"].append(data["metadata"] if "metadata" in data else None)
-            self._chroma_data["ids"].append(data["id"] if "id" in data else str(index))
-
-    def get_kwargs(self):
-        return self._chroma_data
-
-    def get_original_data(self):
-        return self._original_data
-
-
-class ChromaEmbeddingFunction(EmbeddingFunction):
-    def __init__(
-        self, *, embedding_function: Callable[[list[str]], Embeddings] | None = None, agent: BaseAgent | None = None
-    ):
-        if embedding_function:
-            self.embedding_function = embedding_function
-        elif agent:
-
-            def embedding_function_by_agent(texts: list[str]) -> Embeddings:
-                return agent.input(texts).start()
-
-            self.embedding_function = embedding_function_by_agent
-        else:
-            raise ValueError(
-                f"ChromaEmbeddingFunction() requires at least one definition for 'embedding_function' or 'agent'."
-            )
-
-    def __call__(self, documents: Documents) -> Embeddings:
-        return self.embedding_function([document for document in documents])