cohere-haystack 2.0.2__tar.gz → 3.0.0__tar.gz

{cohere_haystack-2.0.2 → cohere_haystack-3.0.0}/CHANGELOG.md

@@ -1,5 +1,17 @@
 # Changelog
 
+## [integrations/cohere-v2.0.2] - 2025-01-15
+
+### 🐛 Bug Fixes
+
+- Make GoogleAI Chat Generator compatible with new `ChatMessage`; small fixes to Cohere tests (#1253)
+- Cohere - fix chat message creation (#1289)
+
+### 🌀 Miscellaneous
+
+- Test: remove tests involving serialization of lambdas (#1281)
+- Test: remove more tests involving serialization of lambdas (#1285)
+
 ## [integrations/cohere-v2.0.1] - 2024-12-09
 
 ### ⚙️ CI

{cohere_haystack-2.0.2 → cohere_haystack-3.0.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cohere-haystack
-Version: 2.0.2
+Version: 3.0.0
 Project-URL: Documentation, https://github.com/deepset-ai/haystack-core-integrations/tree/main/integrations/cohere#readme
 Project-URL: Issues, https://github.com/deepset-ai/haystack-core-integrations/issues
 Project-URL: Source, https://github.com/deepset-ai/haystack-core-integrations/tree/main/integrations/cohere

{cohere_haystack-2.0.2 → cohere_haystack-3.0.0}/pyproject.toml

@@ -47,6 +47,7 @@ dependencies = [
   "pytest",
   "pytest-rerunfailures",
   "haystack-pydoc-tools",
+  "jsonschema" # for tools
 ]
 [tool.hatch.envs.default.scripts]
 test = "pytest {args:tests}"

{cohere_haystack-2.0.2 → cohere_haystack-3.0.0}/src/haystack_integrations/components/embedders/cohere/document_embedder.py

@@ -7,7 +7,8 @@ from typing import Any, Dict, List, Optional
 from haystack import Document, component, default_from_dict, default_to_dict
 from haystack.utils import Secret, deserialize_secrets_inplace
 
-from cohere import AsyncClient, Client
+from cohere import AsyncClientV2, ClientV2
+from haystack_integrations.components.embedders.cohere.embedding_types import EmbeddingTypes
 from haystack_integrations.components.embedders.cohere.utils import get_async_response, get_response
 
 
@@ -47,6 +48,7 @@ class CohereDocumentEmbedder:
         progress_bar: bool = True,
         meta_fields_to_embed: Optional[List[str]] = None,
         embedding_separator: str = "\n",
+        embedding_type: Optional[EmbeddingTypes] = None,
     ):
         """
         :param api_key: the Cohere API key.
@@ -72,6 +74,8 @@ class CohereDocumentEmbedder:
                              to keep the logs clean.
         :param meta_fields_to_embed: list of meta fields that should be embedded along with the Document text.
         :param embedding_separator: separator used to concatenate the meta fields to the Document text.
+        :param embedding_type: the type of embeddings to return. Defaults to float embeddings.
+            Note that int8, uint8, binary, and ubinary are only valid for v3 models.
         """
 
         self.api_key = api_key
@@ -85,6 +89,7 @@ class CohereDocumentEmbedder:
         self.progress_bar = progress_bar
         self.meta_fields_to_embed = meta_fields_to_embed or []
         self.embedding_separator = embedding_separator
+        self.embedding_type = embedding_type or EmbeddingTypes.FLOAT
 
     def to_dict(self) -> Dict[str, Any]:
         """
@@ -106,6 +111,7 @@ class CohereDocumentEmbedder:
             progress_bar=self.progress_bar,
             meta_fields_to_embed=self.meta_fields_to_embed,
             embedding_separator=self.embedding_separator,
+            embedding_type=self.embedding_type.value,
         )
 
     @classmethod
@@ -120,6 +126,10 @@ class CohereDocumentEmbedder:
         """
         init_params = data.get("init_parameters", {})
         deserialize_secrets_inplace(init_params, ["api_key"])
+
+        # Convert embedding_type string to EmbeddingTypes enum value
+        init_params["embedding_type"] = EmbeddingTypes.from_str(init_params["embedding_type"])
+
         return default_from_dict(cls, data)
 
     def _prepare_texts_to_embed(self, documents: List[Document]) -> List[str]:
@@ -163,17 +173,19 @@ class CohereDocumentEmbedder:
         assert api_key is not None
 
         if self.use_async_client:
-            cohere_client = AsyncClient(
+            cohere_client = AsyncClientV2(
                 api_key,
                 base_url=self.api_base_url,
                 timeout=self.timeout,
                 client_name="haystack",
             )
             all_embeddings, metadata = asyncio.run(
-                get_async_response(cohere_client, texts_to_embed, self.model, self.input_type, self.truncate)
+                get_async_response(
+                    cohere_client, texts_to_embed, self.model, self.input_type, self.truncate, self.embedding_type
+                )
             )
         else:
-            cohere_client = Client(
+            cohere_client = ClientV2(
                 api_key,
                 base_url=self.api_base_url,
                 timeout=self.timeout,
@@ -187,6 +199,7 @@ class CohereDocumentEmbedder:
                 self.truncate,
                 self.batch_size,
                 self.progress_bar,
+                self.embedding_type,
             )
 
         for doc, embeddings in zip(documents, all_embeddings):

cohere_haystack-3.0.0/src/haystack_integrations/components/embedders/cohere/embedding_types.py

@@ -0,0 +1,37 @@
+# SPDX-FileCopyrightText: 2023-present deepset GmbH <info@deepset.ai>
+#
+# SPDX-License-Identifier: Apache-2.0
+from enum import Enum
+
+
+class EmbeddingTypes(Enum):
+    """
+    Supported types for Cohere embeddings.
+
+    FLOAT: Default float embeddings. Valid for all models.
+    INT8: Signed int8 embeddings. Valid for only v3 models.
+    UINT8: Unsigned int8 embeddings. Valid for only v3 models.
+    BINARY: Signed binary embeddings. Valid for only v3 models.
+    UBINARY: Unsigned binary embeddings. Valid for only v3 models.
+    """
+
+    FLOAT = "float"
+    INT8 = "int8"
+    UINT8 = "uint8"
+    BINARY = "binary"
+    UBINARY = "ubinary"
+
+    def __str__(self):
+        return self.value
+
+    @staticmethod
+    def from_str(string: str) -> "EmbeddingTypes":
+        """
+        Convert a string to an EmbeddingTypes enum.
+        """
+        enum_map = {e.value: e for e in EmbeddingTypes}
+        embedding_type = enum_map.get(string.lower())
+        if embedding_type is None:
+            msg = f"Unknown embedding type '{string}'. Supported types are: {list(enum_map.keys())}"
+            raise ValueError(msg)
+        return embedding_type

{cohere_haystack-2.0.2 → cohere_haystack-3.0.0}/src/haystack_integrations/components/embedders/cohere/text_embedder.py

@@ -2,12 +2,13 @@
 #
 # SPDX-License-Identifier: Apache-2.0
 import asyncio
-from typing import Any, Dict, List
+from typing import Any, Dict, List, Optional
 
 from haystack import component, default_from_dict, default_to_dict
 from haystack.utils import Secret, deserialize_secrets_inplace
 
-from cohere import AsyncClient, Client
+from cohere import AsyncClientV2, ClientV2
+from haystack_integrations.components.embedders.cohere.embedding_types import EmbeddingTypes
 from haystack_integrations.components.embedders.cohere.utils import get_async_response, get_response
 
 
@@ -40,6 +41,7 @@ class CohereTextEmbedder:
         truncate: str = "END",
         use_async_client: bool = False,
         timeout: int = 120,
+        embedding_type: Optional[EmbeddingTypes] = None,
     ):
         """
         :param api_key: the Cohere API key.
@@ -60,6 +62,8 @@ class CohereTextEmbedder:
         :param use_async_client: flag to select the AsyncClient. It is recommended to use
             AsyncClient for applications with many concurrent calls.
         :param timeout: request timeout in seconds.
+        :param embedding_type: the type of embeddings to return. Defaults to float embeddings.
+            Note that int8, uint8, binary, and ubinary are only valid for v3 models.
         """
 
         self.api_key = api_key
@@ -69,6 +73,7 @@ class CohereTextEmbedder:
         self.truncate = truncate
         self.use_async_client = use_async_client
         self.timeout = timeout
+        self.embedding_type = embedding_type or EmbeddingTypes.FLOAT
 
     def to_dict(self) -> Dict[str, Any]:
         """
@@ -86,6 +91,7 @@ class CohereTextEmbedder:
             truncate=self.truncate,
             use_async_client=self.use_async_client,
             timeout=self.timeout,
+            embedding_type=self.embedding_type.value,
         )
 
     @classmethod
@@ -100,6 +106,10 @@ class CohereTextEmbedder:
         """
         init_params = data.get("init_parameters", {})
         deserialize_secrets_inplace(init_params, ["api_key"])
+
+        # Convert embedding_type string to EmbeddingTypes enum value
+        init_params["embedding_type"] = EmbeddingTypes.from_str(init_params["embedding_type"])
+
         return default_from_dict(cls, data)
 
     @component.output_types(embedding=List[float], meta=Dict[str, Any])
@@ -125,22 +135,26 @@ class CohereTextEmbedder:
         assert api_key is not None
 
         if self.use_async_client:
-            cohere_client = AsyncClient(
+            cohere_client = AsyncClientV2(
                 api_key,
                 base_url=self.api_base_url,
                 timeout=self.timeout,
                 client_name="haystack",
             )
             embedding, metadata = asyncio.run(
-                get_async_response(cohere_client, [text], self.model, self.input_type, self.truncate)
+                get_async_response(
+                    cohere_client, [text], self.model, self.input_type, self.truncate, self.embedding_type
+                )
             )
         else:
-            cohere_client = Client(
+            cohere_client = ClientV2(
                 api_key,
                 base_url=self.api_base_url,
                 timeout=self.timeout,
                 client_name="haystack",
             )
-            embedding, metadata = get_response(cohere_client, [text], self.model, self.input_type, self.truncate)
+            embedding, metadata = get_response(
+                cohere_client, [text], self.model, self.input_type, self.truncate, embedding_type=self.embedding_type
+            )
 
         return {"embedding": embedding[0], "meta": metadata}

cohere_haystack-3.0.0/src/haystack_integrations/components/embedders/cohere/utils.py

@@ -0,0 +1,112 @@
+# SPDX-FileCopyrightText: 2023-present deepset GmbH <info@deepset.ai>
+#
+# SPDX-License-Identifier: Apache-2.0
+from typing import Any, Dict, List, Optional, Tuple
+
+from tqdm import tqdm
+
+from cohere import AsyncClientV2, ClientV2
+from haystack_integrations.components.embedders.cohere.embedding_types import EmbeddingTypes
+
+
+async def get_async_response(
+    cohere_async_client: AsyncClientV2,
+    texts: List[str],
+    model_name,
+    input_type,
+    truncate,
+    embedding_type: Optional[EmbeddingTypes] = None,
+):
+    """Embeds a list of texts asynchronously using the Cohere API.
+
+    :param cohere_async_client: the Cohere `AsyncClient`
+    :param texts: the texts to embed
+    :param model_name: the name of the model to use
+    :param input_type: one of "classification", "clustering", "search_document", "search_query".
+        The type of input text provided to embed.
+    :param truncate: one of "NONE", "START", "END". How the API handles text longer than the maximum token length.
+    :param embedding_type: the type of embeddings to return. Defaults to float embeddings.
+
+    :returns: A tuple of the embeddings and metadata.
+
+    :raises ValueError: If an error occurs while querying the Cohere API.
+    """
+    all_embeddings: List[List[float]] = []
+    metadata: Dict[str, Any] = {}
+
+    embedding_type = embedding_type or EmbeddingTypes.FLOAT
+    response = await cohere_async_client.embed(
+        texts=texts,
+        model=model_name,
+        input_type=input_type,
+        truncate=truncate,
+        embedding_types=[embedding_type.value],
+    )
+    if response.meta is not None:
+        metadata = response.meta
+    for emb_tuple in response.embeddings:
+        # emb_tuple[0] is a str denoting the embedding type (e.g. "float", "int8", etc.)
+        if emb_tuple[1] is not None:
+            # ok we have embeddings for this type, let's take all
+            # the embeddings (a list of embeddings) and break the loop
+            all_embeddings.extend(emb_tuple[1])
+            break
+
+    return all_embeddings, metadata
+
+
+def get_response(
+    cohere_client: ClientV2,
+    texts: List[str],
+    model_name,
+    input_type,
+    truncate,
+    batch_size=32,
+    progress_bar=False,
+    embedding_type: Optional[EmbeddingTypes] = None,
+) -> Tuple[List[List[float]], Dict[str, Any]]:
+    """Embeds a list of texts using the Cohere API.
+
+    :param cohere_client: the Cohere `Client`
+    :param texts: the texts to embed
+    :param model_name: the name of the model to use
+    :param input_type: one of "classification", "clustering", "search_document", "search_query".
+        The type of input text provided to embed.
+    :param truncate: one of "NONE", "START", "END". How the API handles text longer than the maximum token length.
+    :param batch_size: the batch size to use
+    :param progress_bar: if `True`, show a progress bar
+    :param embedding_type: the type of embeddings to return. Defaults to float embeddings.
+
+    :returns: A tuple of the embeddings and metadata.
+
+    :raises ValueError: If an error occurs while querying the Cohere API.
+    """
+
+    all_embeddings: List[List[float]] = []
+    metadata: Dict[str, Any] = {}
+    embedding_type = embedding_type or EmbeddingTypes.FLOAT
+
+    for i in tqdm(
+        range(0, len(texts), batch_size),
+        disable=not progress_bar,
+        desc="Calculating embeddings",
+    ):
+        batch = texts[i : i + batch_size]
+        response = cohere_client.embed(
+            texts=batch,
+            model=model_name,
+            input_type=input_type,
+            truncate=truncate,
+            embedding_types=[embedding_type.value],
+        )
+        ## response.embeddings always returns 5 tuples, one tuple per embedding type
+        ## let's take first non None tuple as that's the one we want
+        for emb_tuple in response.embeddings:
+            # emb_tuple[0] is a str denoting the embedding type (e.g. "float", "int8", etc.)
+            if emb_tuple[1] is not None:
+                # ok we have embeddings for this type, let's take all the embeddings (a list of embeddings)
+                all_embeddings.extend(emb_tuple[1])
+        if response.meta is not None:
+            metadata = response.meta
+
+    return all_embeddings, metadata