agently 4.0.6.4__tar.gz → 4.0.6.6__tar.gz

{agently-4.0.6.4 → agently-4.0.6.6}/PKG-INFO

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

{agently-4.0.6.4 → agently-4.0.6.6}/agently/builtins/plugins/PromptGenerator/AgentlyPromptGenerator.py

@@ -307,9 +307,7 @@ class AgentlyPromptGenerator(PromptGenerator):
         if isinstance(role_mapping, dict):
             merged_role_mapping.update(role_mapping)
 
-        prompt_text_list.append(
-            f"{ (merged_role_mapping['user'] if 'user' in merged_role_mapping else 'user').upper() }:"
-        )
+        prompt_text_list.append(f"{ (merged_role_mapping['user'] if 'user' in merged_role_mapping else 'user') }:")
 
         # system & developer
         if prompt_object.system:
@@ -368,7 +366,7 @@ class AgentlyPromptGenerator(PromptGenerator):
 
         prompt_text_list.extend(self._generate_main_prompt(prompt_object))
         prompt_text_list.append(
-            f"{ (merged_role_mapping['assistant'] if 'assistant' in merged_role_mapping else 'assistant').upper() }:"
+            f"{ (merged_role_mapping['assistant'] if 'assistant' in merged_role_mapping else 'assistant') }:"
         )
 
         return "\n".join(prompt_text_list)
@@ -398,12 +396,7 @@ class AgentlyPromptGenerator(PromptGenerator):
         if prompt_object.system:
             prompt_messages.append(
                 self._generate_yaml_prompt_message(
-                    str(
-                        prompt_title_mapping.get(
-                            'system',
-                            'SYSTEM',
-                        )
-                    ),
+                    "system",
                     prompt_object.system,
                     role_mapping=merged_role_mapping,
                 )
@@ -412,12 +405,7 @@ class AgentlyPromptGenerator(PromptGenerator):
         if prompt_object.developer:
             prompt_messages.append(
                 self._generate_yaml_prompt_message(
-                    str(
-                        prompt_title_mapping.get(
-                            'developer',
-                            'DEVELOPER DIRECTIONS',
-                        )
-                    ),
+                    "developer",
                     prompt_object.developer,
                     role_mapping=merged_role_mapping,
                 )

agently-4.0.6.6/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.4 → agently-4.0.6.6}/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.4 → agently-4.0.6.6}/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.4 → agently-4.0.6.6}/pyproject.toml

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

agently-4.0.6.4/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])