haystack-experimental 0.14.2__py3-none-any.whl → 0.15.0__py3-none-any.whl

haystack_experimental/components/query/query_expander.py

@@ -1,299 +0,0 @@
-# SPDX-FileCopyrightText: 2022-present deepset GmbH <info@deepset.ai>
-#
-# SPDX-License-Identifier: Apache-2.0
-
-import json
-from typing import Any, Dict, List, Optional
-
-from haystack import default_from_dict, default_to_dict, logging
-from haystack.components.builders.prompt_builder import PromptBuilder
-from haystack.components.generators.chat.openai import OpenAIChatGenerator
-from haystack.components.generators.chat.types import ChatGenerator
-from haystack.core.component import component
-from haystack.core.serialization import component_to_dict
-from haystack.dataclasses.chat_message import ChatMessage
-from haystack.utils.deserialization import deserialize_chatgenerator_inplace
-
-logger = logging.getLogger(__name__)
-
-
-DEFAULT_PROMPT_TEMPLATE = """
-You are part of an information system that processes user queries for retrieval.
-You have to expand a given query into {{ n_expansions }} queries that are
-semantically similar to improve retrieval recall.
-
-Structure:
-Follow the structure shown below in examples to generate expanded queries.
-
-Examples:
-1.  Query: "climate change effects"
-    {"queries": ["impact of climate change", "consequences of global warming", "effects of environmental changes"]}
-
-2.  Query: "machine learning algorithms"
-    {"queries": ["neural networks", "clustering techniques", "supervised learning methods", "deep learning models"]}
-
-3.  Query: "open source NLP frameworks"
-    {"queries": ["natural language processing tools", "free nlp libraries", "open-source NLP platforms"]}
-
-Guidelines:
-- Generate queries that use different words and phrasings
-- Include synonyms and related terms
-- Maintain the same core meaning and intent
-- Make queries that are likely to retrieve relevant information the original might miss
-- Focus on variations that would work well with keyword-based search
-- Respond in the same language as the input query
-
-Your Task:
-Query: "{{ query }}"
-
-You *must* respond with a JSON object containing a "queries" array with the expanded queries.
-Example: {"queries": ["query1", "query2", "query3"]}"""
-
-
-@component
-class QueryExpander:
-    """
-    A component that returns a list of semantically similar queries to improve retrieval recall in RAG systems.
-
-    The component uses a chat generator to expand queries. The chat generator is expected to return a JSON response
-    with the following structure:
-    ```json
-    {"queries": ["expanded query 1", "expanded query 2", "expanded query 3"]}
-    ```
-
-    ### Usage example
-
-    ```python
-    from haystack.components.generators.chat.openai import OpenAIChatGenerator
-    from haystack_experimental.components.query import QueryExpander
-
-    expander = QueryExpander(
-        chat_generator=OpenAIChatGenerator(model="gpt-4.1-mini"),
-        n_expansions=3
-    )
-
-    result = expander.run(query="green energy sources")
-    print(result["queries"])
-    # Output: ['alternative query 1', 'alternative query 2', 'alternative query 3', 'green energy sources']
-    # Note: Up to 3 additional queries + 1 original query (if include_original_query=True)
-
-    # To control total number of queries:
-    expander = QueryExpander(n_expansions=2, include_original_query=True)  # Up to 3 total
-    # or
-    expander = QueryExpander(n_expansions=3, include_original_query=False)  # Exactly 3 total
-    ```
-    """
-
-    def __init__(
-        self,
-        *,
-        chat_generator: Optional[ChatGenerator] = None,
-        prompt_template: Optional[str] = None,
-        n_expansions: int = 4,
-        include_original_query: bool = True,
-    ):
-        """
-        Initialize the QueryExpander component.
-
-        :param chat_generator: The chat generator component to use for query expansion.
-            If None, a default OpenAIChatGenerator with gpt-4.1-mini model is used.
-        :param prompt_template: Custom [PromptBuilder](https://docs.haystack.deepset.ai/docs/promptbuilder)
-            template for query expansion. The template should instruct the LLM to return a JSON response with the
-            structure: `{"queries": ["query1", "query2", "query3"]}`. The template should include 'query' and
-            'n_expansions' variables.
-        :param n_expansions: Number of alternative queries to generate (default: 4).
-        :param include_original_query: Whether to include the original query in the output.
-        """
-        if n_expansions <= 0:
-            raise ValueError("n_expansions must be positive")
-
-        self.n_expansions = n_expansions
-        self.include_original_query = include_original_query
-
-        if chat_generator is None:
-            self.chat_generator: ChatGenerator = OpenAIChatGenerator(
-                model="gpt-4.1-mini",
-                generation_kwargs={
-                    "temperature": 0.7,
-                    "response_format": {
-                        "type": "json_schema",
-                        "json_schema": {
-                            "name": "query_expansion",
-                            "schema": {
-                                "type": "object",
-                                "properties": {"queries": {"type": "array", "items": {"type": "string"}}},
-                                "required": ["queries"],
-                                "additionalProperties": False,
-                            },
-                        },
-                    },
-                    "seed": 42,
-                },
-            )
-        else:
-            self.chat_generator = chat_generator
-
-        self._is_warmed_up = False
-        self._supports_warm_up = hasattr(self.chat_generator, "warm_up")
-        self.prompt_template = prompt_template or DEFAULT_PROMPT_TEMPLATE
-
-        # Check if required variables are present in the template
-        if "query" not in self.prompt_template:
-            logger.warning(
-                "The prompt template does not contain the 'query' variable. This may cause issues during execution."
-            )
-        if "n_expansions" not in self.prompt_template:
-            logger.warning(
-                "The prompt template does not contain the 'n_expansions' variable. "
-                "This may cause issues during execution."
-            )
-
-        self._prompt_builder = PromptBuilder(
-            template=self.prompt_template,
-            required_variables=["n_expansions", "query"],
-        )
-
-    def to_dict(self) -> Dict[str, Any]:
-        """
-        Serializes the component to a dictionary.
-
-        :return: Dictionary with serialized data.
-        """
-        return default_to_dict(
-            self,
-            chat_generator=component_to_dict(self.chat_generator, name="chat_generator"),
-            prompt_template=self.prompt_template,
-            n_expansions=self.n_expansions,
-            include_original_query=self.include_original_query,
-        )
-
-    @classmethod
-    def from_dict(cls, data: Dict[str, Any]) -> "QueryExpander":
-        """
-        Deserializes the component from a dictionary.
-
-        :param data: Dictionary with serialized data.
-        :return: Deserialized component.
-        """
-        init_params = data.get("init_parameters", {})
-
-        deserialize_chatgenerator_inplace(init_params, key="chat_generator")
-
-        return default_from_dict(cls, data)
-
-    @component.output_types(queries=List[str])
-    def run(
-        self,
-        query: str,
-        n_expansions: Optional[int] = None,
-    ) -> Dict[str, List[str]]:
-        """
-        Expand the input query into multiple semantically similar queries.
-
-        The language of the original query is preserved in the expanded queries.
-
-        :param query: The original query to expand.
-        :param n_expansions: Number of additional queries to generate (not including the original).
-            If None, uses the value from initialization. Can be 0 to generate no additional queries.
-        :return: Dictionary with "queries" key containing the list of expanded queries.
-            If include_original_query=True, the original query will be included in addition
-            to the n_expansions alternative queries.
-        :raises ValueError: If n_expansions is not positive (less than or equal to 0).
-        :raises RuntimeError: If the component is not warmed up and the chat generator does not support warm up.
-        """
-
-        if not self._is_warmed_up and self._supports_warm_up:
-            raise RuntimeError("The component is not warmed up. Please call the `warm_up` method first.")
-
-        response = {"queries": [query] if self.include_original_query else []}
-
-        if not query.strip():
-            logger.warning("Empty query provided to QueryExpander")
-            return response
-
-        expansion_count = n_expansions if n_expansions is not None else self.n_expansions
-        if expansion_count <= 0:
-            raise ValueError("n_expansions must be positive")
-
-        try:
-            prompt_result = self._prompt_builder.run(query=query.strip(), n_expansions=expansion_count)
-            generator_result = self.chat_generator.run(messages=[ChatMessage.from_user(prompt_result["prompt"])])
-
-            if not generator_result.get("replies") or len(generator_result["replies"]) == 0:
-                logger.warning("ChatGenerator returned no replies for query: {query}", query=query)
-                return response
-
-            expanded_text = generator_result["replies"][0].text.strip()
-            expanded_queries = self._parse_expanded_queries(expanded_text)
-
-            # Limit the number of expanded queries to the requested amount
-            if len(expanded_queries) > expansion_count:
-                logger.warning(
-                    "Generated {generated_count} queries but only {requested_count} were requested. "
-                    "Truncating to the first {requested_count} queries. ",
-                    generated_count=len(expanded_queries),
-                    requested_count=expansion_count,
-                )
-                expanded_queries = expanded_queries[:expansion_count]
-
-            # Add original query if requested and remove duplicates
-            if self.include_original_query:
-                expanded_queries_lower = [q.lower() for q in expanded_queries]
-                if query.lower() not in expanded_queries_lower:
-                    expanded_queries.append(query)
-
-            response["queries"] = expanded_queries
-            return response
-
-        except Exception as e:
-            # Fallback: return original query to maintain pipeline functionality
-            logger.error("Failed to expand query {query}: {error}", query=query, error=str(e))
-            return response
-
-    def warm_up(self):
-        """
-        Warm up the underlying LLM if it supports it.
-        """
-        if not self._is_warmed_up and self._supports_warm_up:
-            self.chat_generator.warm_up()  # type: ignore[attr-defined]
-            self._is_warmed_up = True
-
-    @staticmethod
-    def _parse_expanded_queries(generator_response: str) -> List[str]:
-        """
-        Parse the generator response to extract individual expanded queries.
-
-        :param generator_response: The raw text response from the generator.
-        :return: List of parsed expanded queries.
-        """
-        if not generator_response.strip():
-            return []
-
-        try:
-            parsed = json.loads(generator_response)
-            if not isinstance(parsed, dict) or "queries" not in parsed:
-                logger.warning(
-                    "Generator response is not a JSON object containing a 'queries' array: {response}",
-                    response=generator_response[:100],
-                )
-                return []
-
-            queries = []
-            for item in parsed["queries"]:
-                if isinstance(item, str) and item.strip():
-                    queries.append(item.strip())
-                else:
-                    logger.warning(
-                        "Skipping non-string or empty query in response: {item}",
-                        item=item,
-                    )
-
-            return queries
-
-        except json.JSONDecodeError as e:
-            logger.warning(
-                "Failed to parse JSON response: {error}. Response: {response}",
-                error=str(e),
-                response=generator_response[:100],
-            )
-            return []

haystack_experimental/components/retrievers/multi_query_embedding_retriever.py

@@ -1,180 +0,0 @@
-# SPDX-FileCopyrightText: 2022-present deepset GmbH <info@deepset.ai>
-#
-# SPDX-License-Identifier: Apache-2.0
-
-from concurrent.futures import ThreadPoolExecutor
-from typing import Any, List, Optional
-
-from haystack import Document, component, default_from_dict, default_to_dict
-from haystack.components.embedders.types.protocol import TextEmbedder
-from haystack.core.serialization import component_to_dict
-from haystack.utils.deserialization import deserialize_component_inplace
-
-from haystack_experimental.components.retrievers.types import EmbeddingRetriever
-
-
-@component
-class MultiQueryEmbeddingRetriever:
-    """
-    A component that retrieves documents using multiple queries in parallel with an embedding-based retriever.
-
-    This component takes a list of text queries, converts them to embeddings using a query embedder,
-    and then uses an embedding-based retriever to find relevant documents for each query in parallel.
-    The results are combined and sorted by relevance score.
-
-    ### Usage example
-
-    ```python
-    from haystack import Document
-    from haystack.document_stores.in_memory import InMemoryDocumentStore
-    from haystack.document_stores.types import DuplicatePolicy
-    from haystack.components.embedders import SentenceTransformersTextEmbedder
-    from haystack.components.embedders import SentenceTransformersDocumentEmbedder
-    from haystack.components.retrievers import InMemoryEmbeddingRetriever
-    from haystack.components.writers import DocumentWriter
-    from haystack_experimental.components.retrievers import MultiQueryEmbeddingRetriever
-
-    documents = [
-        Document(content="Renewable energy is energy that is collected from renewable resources."),
-        Document(content="Solar energy is a type of green energy that is harnessed from the sun."),
-        Document(content="Wind energy is another type of green energy that is generated by wind turbines."),
-        Document(content="Geothermal energy is heat that comes from the sub-surface of the earth."),
-        Document(content="Biomass energy is produced from organic materials, such as plant and animal waste."),
-        Document(content="Fossil fuels, such as coal, oil, and natural gas, are non-renewable energy sources."),
-    ]
-
-    # Populate the document store
-    doc_store = InMemoryDocumentStore()
-    doc_embedder = SentenceTransformersDocumentEmbedder(model="sentence-transformers/all-MiniLM-L6-v2")
-    doc_embedder.warm_up()
-    doc_writer = DocumentWriter(document_store=doc_store, policy=DuplicatePolicy.SKIP)
-    documents = doc_embedder.run(documents)["documents"]
-    doc_writer.run(documents=documents)
-
-    # Run the multi-query retriever
-    in_memory_retriever = InMemoryEmbeddingRetriever(document_store=doc_store, top_k=1)
-    query_embedder = SentenceTransformersTextEmbedder(model="sentence-transformers/all-MiniLM-L6-v2")
-
-    multi_query_retriever = MultiQueryEmbeddingRetriever(
-        retriever=in_memory_retriever,
-        query_embedder=query_embedder,
-        max_workers=3
-    )
-
-    queries = ["Geothermal energy", "natural gas", "turbines"]
-    result = multi_query_retriever.run(queries=queries)
-    for doc in result["documents"]:
-        print(f"Content: {doc.content}, Score: {doc.score}")
-    >> Content: Geothermal energy is heat that comes from the sub-surface of the earth., Score: 0.8509603046266574
-    >> Content: Renewable energy is energy that is collected from renewable resources., Score: 0.42763211298893034
-    >> Content: Solar energy is a type of green energy that is harnessed from the sun., Score: 0.40077417016494354
-    >> Content: Fossil fuels, such as coal, oil, and natural gas, are non-renewable energy sources., Score: 0.3774863680995796
-    >> Content: Wind energy is another type of green energy that is generated by wind turbines., Score: 0.3091423972562246
-    >> Content: Biomass energy is produced from organic materials, such as plant and animal waste., Score: 0.25173074243668087
-    ```
-    """  # noqa E501
-
-    def __init__(
-        self,
-        *,
-        retriever: EmbeddingRetriever,
-        query_embedder: TextEmbedder,
-        max_workers: int = 3,
-    ):
-        """
-        Initialize MultiQueryEmbeddingRetriever.
-
-        :param retriever: The embedding-based retriever to use for document retrieval.
-        :param query_embedder: The query embedder to convert text queries to embeddings.
-        :param max_workers: Maximum number of worker threads for parallel processing.
-        """
-        self.retriever = retriever
-        self.query_embedder = query_embedder
-        self.max_workers = max_workers
-        self._is_warmed_up = False
-
-    def warm_up(self) -> None:
-        """
-        Warm up the query embedder and the retriever if any has a warm_up method.
-        """
-        if not self._is_warmed_up:
-            if hasattr(self.query_embedder, "warm_up") and callable(getattr(self.query_embedder, "warm_up")):
-                self.query_embedder.warm_up()
-            if hasattr(self.retriever, "warm_up") and callable(getattr(self.retriever, "warm_up")):
-                self.retriever.warm_up()
-            self._is_warmed_up = True
-
-    @component.output_types(documents=List[Document])
-    def run(
-        self,
-        queries: List[str],
-        retriever_kwargs: Optional[dict[str, Any]] = None,
-    ) -> dict[str, Any]:
-        """
-        Retrieve documents using multiple queries in parallel.
-
-        :param queries: List of text queries to process.
-        :param retriever_kwargs: Optional dictionary of arguments to pass to the retriever's run method.
-        :returns:
-            A dictionary containing:
-                - `documents`: List of retrieved documents sorted by relevance score.
-        """
-        docs: list[Document] = []
-        seen_contents = set()
-        retriever_kwargs = retriever_kwargs or {}
-
-        with ThreadPoolExecutor(max_workers=self.max_workers) as executor:
-            queries_results = executor.map(lambda query: self._run_on_thread(query, retriever_kwargs), queries)
-            for result in queries_results:
-                if not result:
-                    continue
-                for doc in result:
-                    # deduplicate based on content
-                    if doc.content not in seen_contents:
-                        docs.append(doc)
-                        seen_contents.add(doc.content)
-
-        docs.sort(key=lambda x: x.score or 0.0, reverse=True)
-        return {"documents": docs}
-
-    def _run_on_thread(self, query: str, retriever_kwargs: Optional[dict[str, Any]] = None) -> Optional[List[Document]]:
-        """
-        Process a single query on a separate thread.
-
-        :param query: The text query to process.
-        :returns:
-            List of retrieved documents or None if no results.
-        """
-        embedding_result = self.query_embedder.run(text=query)
-        query_embedding = embedding_result["embedding"]
-        result = self.retriever.run(query_embedding=query_embedding, **(retriever_kwargs or {}))
-        if result and "documents" in result:
-            return result["documents"]
-        return None
-
-    def to_dict(self) -> dict[str, Any]:
-        """
-        Serializes the component to a dictionary.
-
-        :returns:
-            A dictionary representing the serialized component.
-        """
-        return default_to_dict(
-            self,
-            retriever=component_to_dict(obj=self.retriever, name="retriever"),
-            query_embedder=component_to_dict(obj=self.query_embedder, name="query_embedder"),
-            max_workers=self.max_workers,
-        )
-
-    @classmethod
-    def from_dict(cls, data: dict[str, Any]) -> "MultiQueryEmbeddingRetriever":
-        """
-        Deserializes the component from a dictionary.
-
-        :param data: The dictionary to deserialize from.
-        :returns:
-            The deserialized component.
-        """
-        deserialize_component_inplace(data["init_parameters"], key="retriever")
-        deserialize_component_inplace(data["init_parameters"], key="query_embedder")
-        return default_from_dict(cls, data)

haystack_experimental/components/retrievers/multi_query_text_retriever.py

@@ -1,158 +0,0 @@
-# SPDX-FileCopyrightText: 2022-present deepset GmbH <info@deepset.ai>
-#
-# SPDX-License-Identifier: Apache-2.0
-
-from concurrent.futures import ThreadPoolExecutor
-from typing import Any, List, Optional
-
-from haystack import Document, component, default_from_dict, default_to_dict
-from haystack.core.serialization import component_to_dict
-from haystack.utils.deserialization import deserialize_component_inplace
-
-from haystack_experimental.components.retrievers.types import TextRetriever
-
-
-@component
-class MultiQueryTextRetriever:
-    """
-    A component that retrieves documents using multiple queries in parallel with a text-based retriever.
-
-    This component takes a list of text queries and uses a text-based retriever to find relevant documents for each
-    query in parallel, using a thread pool to manage concurrent execution. The results are combined and sorted by
-    relevance score.
-
-    You can use this component in combination with QueryExpander component to enhance the retrieval process.
-
-    ### Usage example
-    ```python
-    from haystack import Document
-    from haystack.components.writers import DocumentWriter
-    from haystack.document_stores.in_memory import InMemoryDocumentStore
-    from haystack.document_stores.types import DuplicatePolicy
-    from haystack.components.retrievers import InMemoryBM25Retriever
-    from haystack_experimental.components.query import QueryExpander
-    from haystack_experimental.components.retrievers.multi_query_text_retriever import MultiQueryTextRetriever
-
-    documents = [
-        Document(content="Renewable energy is energy that is collected from renewable resources."),
-        Document(content="Solar energy is a type of green energy that is harnessed from the sun."),
-        Document(content="Wind energy is another type of green energy that is generated by wind turbines."),
-        Document(content="Hydropower is a form of renewable energy using the flow of water to generate electricity."),
-        Document(content="Geothermal energy is heat that comes from the sub-surface of the earth.")
-    ]
-
-    document_store = InMemoryDocumentStore()
-    doc_writer = DocumentWriter(document_store=document_store, policy=DuplicatePolicy.SKIP)
-    doc_writer.run(documents=documents)
-
-    in_memory_retriever = InMemoryBM25Retriever(document_store=document_store, top_k=1)
-    multiquery_retriever = MultiQueryTextRetriever(retriever=in_memory_retriever)
-    results = multiquery_retriever.run(queries=["renewable energy?", "Geothermal", "Hydropower"])
-    for doc in results["documents"]:
-        print(f"Content: {doc.content}, Score: {doc.score}")
-    >>
-    >> Content: Geothermal energy is heat that comes from the sub-surface of the earth., Score: 1.6474448833731097
-    >> Content: Hydropower is a form of renewable energy using the flow of water to generate electricity., Score: 1.6157822790079805
-    >> Content: Renewable energy is energy that is collected from renewable resources., Score: 1.5255309812344944
-    ```
-    """  # noqa E501
-
-    def __init__(
-        self,
-        retriever: TextRetriever,
-        max_workers: int = 3,
-    ):
-        """
-        Initialize MultiQueryTextRetriever.
-
-        :param retriever: The text-based retriever to use for document retrieval.
-        :param max_workers: Maximum number of worker threads for parallel processing. Default is 3.
-        """
-        self.retriever = retriever
-        self.max_workers = max_workers
-        self._is_warmed_up = False
-
-    def warm_up(self) -> None:
-        """
-        Warm up the retriever if it has a warm_up method.
-        """
-        if not self._is_warmed_up:
-            if hasattr(self.retriever, "warm_up") and callable(getattr(self.retriever, "warm_up")):
-                self.retriever.warm_up()
-            self._is_warmed_up = True
-
-    @component.output_types(documents=list[Document])
-    def run(
-        self,
-        queries: List[str],
-        retriever_kwargs: Optional[dict[str, Any]] = None,
-    ) -> dict[str, Any]:
-        """
-        Retrieve documents using multiple queries in parallel.
-
-        :param queries: List of text queries to process.
-        :param retriever_kwargs: Optional dictionary of arguments to pass to the retriever's run method.
-        :returns:
-            A dictionary containing:
-                `documents`: List of retrieved documents sorted by relevance score.
-        """
-        docs: list[Document] = []
-        seen_contents = set()
-        retriever_kwargs = retriever_kwargs or {}
-
-        with ThreadPoolExecutor(max_workers=self.max_workers) as executor:
-            queries_results = executor.map(lambda query: self._run_on_thread(query, retriever_kwargs), queries)
-            for result in queries_results:
-                if not result:
-                    continue
-                # deduplicate based on content
-                for doc in result:
-                    if doc.content not in seen_contents:
-                        docs.append(doc)
-                        seen_contents.add(doc.content)
-
-        docs.sort(key=lambda x: x.score or 0.0, reverse=True)
-        return {"documents": docs}
-
-    def _run_on_thread(
-        self,
-        query: str,
-        retriever_kwargs: Optional[dict[str, Any]] = None,
-    ) -> Optional[list[Document]]:
-        """
-        Process a single query on a separate thread.
-
-        :param query: The text query to process.
-        :param retriever_kwargs: Optional dictionary of arguments to pass to the retriever's run method.
-        :returns:
-            List of retrieved documents or None if no results.
-        """
-        result = self.retriever.run(query=query, **(retriever_kwargs or {}))
-        if result and "documents" in result:
-            return result["documents"]
-        return None
-
-    def to_dict(self) -> dict[str, Any]:
-        """
-        Serializes the component to a dictionary.
-
-        :returns:
-            The serialized component as a dictionary.
-        """
-        return default_to_dict(
-            self,
-            retriever=component_to_dict(obj=self.retriever, name="retriever"),
-            max_workers=self.max_workers,
-        )
-
-    @classmethod
-    def from_dict(cls, data: dict[str, Any]) -> "MultiQueryTextRetriever":
-        """
-        Deserializes the component from a dictionary.
-
-        :param data: The dictionary to deserialize from.
-        :returns:
-            The deserialized component.
-        """
-        deserialize_component_inplace(data["init_parameters"], key="retriever")
-        return default_from_dict(cls, data)

haystack_experimental/super_components/__init__.py

@@ -1,3 +0,0 @@
-# SPDX-FileCopyrightText: 2022-present deepset GmbH <info@deepset.ai>
-#
-# SPDX-License-Identifier: Apache-2.0

haystack_experimental/super_components/indexers/__init__.py

@@ -1,11 +0,0 @@
-# SPDX-FileCopyrightText: 2022-present deepset GmbH <info@deepset.ai>
-#
-# SPDX-License-Identifier: Apache-2.0
-
-from haystack_experimental.super_components.indexers.sentence_transformers_document_indexer import (
-    SentenceTransformersDocumentIndexer,
-)
-
-__all__ = [
-    "SentenceTransformersDocumentIndexer",
-]