multiple: langchain 0.2 in master (#21191)

0.2rc 

migrations

- [x] Move memory
- [x] Move remaining retrievers
- [x] graph_qa chains
- [x] some dependency from evaluation code potentially on math utils
- [x] Move openapi chain from `langchain.chains.api.openapi` to
`langchain_community.chains.openapi`
- [x] Migrate `langchain.chains.ernie_functions` to
`langchain_community.chains.ernie_functions`
- [x] migrate `langchain/chains/llm_requests.py` to
`langchain_community.chains.llm_requests`
- [x] Moving `langchain_community.cross_enoders.base:BaseCrossEncoder`
->
`langchain_community.retrievers.document_compressors.cross_encoder:BaseCrossEncoder`
(namespace not ideal, but it needs to be moved to `langchain` to avoid
circular deps)
- [x] unit tests langchain -- add pytest.mark.community to some unit
tests that will stay in langchain
- [x] unit tests community -- move unit tests that depend on community
to community
- [x] mv integration tests that depend on community to community
- [x] mypy checks

Other todo

- [x] Make deprecation warnings not noisy (need to use warn deprecated
and check that things are implemented properly)
- [x] Update deprecation messages with timeline for code removal (likely
we actually won't be removing things until 0.4 release) -- will give
people more time to transition their code.
- [ ] Add information to deprecation warning to show users how to
migrate their code base using langchain-cli
- [ ] Remove any unnecessary requirements in langchain (e.g., is
SQLALchemy required?)

---------

Co-authored-by: Erick Friis <erick@langchain.dev>

libs/community/langchain_community/query_constructors/milvus.py

@@ -0,0 +1,103 @@
+"""Logic for converting internal query language to a valid Milvus query."""
+from typing import Tuple, Union
+
+from langchain_core.structured_query import (
+    Comparator,
+    Comparison,
+    Operation,
+    Operator,
+    StructuredQuery,
+    Visitor,
+)
+
+COMPARATOR_TO_BER = {
+    Comparator.EQ: "==",
+    Comparator.GT: ">",
+    Comparator.GTE: ">=",
+    Comparator.LT: "<",
+    Comparator.LTE: "<=",
+    Comparator.IN: "in",
+    Comparator.LIKE: "like",
+}
+
+UNARY_OPERATORS = [Operator.NOT]
+
+
+def process_value(value: Union[int, float, str], comparator: Comparator) -> str:
+    """Convert a value to a string and add double quotes if it is a string.
+
+    It required for comparators involving strings.
+
+    Args:
+        value: The value to convert.
+        comparator: The comparator.
+
+    Returns:
+        The converted value as a string.
+    """
+    #
+    if isinstance(value, str):
+        if comparator is Comparator.LIKE:
+            # If the comparator is LIKE, add a percent sign after it for prefix matching
+            # and add double quotes
+            return f'"{value}%"'
+        else:
+            # If the value is already a string, add double quotes
+            return f'"{value}"'
+    else:
+        # If the value is not a string, convert it to a string without double quotes
+        return str(value)
+
+
+class MilvusTranslator(Visitor):
+    """Translate Milvus internal query language elements to valid filters."""
+
+    """Subset of allowed logical operators."""
+    allowed_operators = [Operator.AND, Operator.NOT, Operator.OR]
+
+    """Subset of allowed logical comparators."""
+    allowed_comparators = [
+        Comparator.EQ,
+        Comparator.GT,
+        Comparator.GTE,
+        Comparator.LT,
+        Comparator.LTE,
+        Comparator.IN,
+        Comparator.LIKE,
+    ]
+
+    def _format_func(self, func: Union[Operator, Comparator]) -> str:
+        self._validate_func(func)
+        value = func.value
+        if isinstance(func, Comparator):
+            value = COMPARATOR_TO_BER[func]
+        return f"{value}"
+
+    def visit_operation(self, operation: Operation) -> str:
+        if operation.operator in UNARY_OPERATORS and len(operation.arguments) == 1:
+            operator = self._format_func(operation.operator)
+            return operator + "(" + operation.arguments[0].accept(self) + ")"
+        elif operation.operator in UNARY_OPERATORS:
+            raise ValueError(
+                f'"{operation.operator.value}" can have only one argument in Milvus'
+            )
+        else:
+            args = [arg.accept(self) for arg in operation.arguments]
+            operator = self._format_func(operation.operator)
+            return "(" + (" " + operator + " ").join(args) + ")"
+
+    def visit_comparison(self, comparison: Comparison) -> str:
+        comparator = self._format_func(comparison.comparator)
+        processed_value = process_value(comparison.value, comparison.comparator)
+        attribute = comparison.attribute
+
+        return "( " + attribute + " " + comparator + " " + processed_value + " )"
+
+    def visit_structured_query(
+        self, structured_query: StructuredQuery
+    ) -> Tuple[str, dict]:
+        if structured_query.filter is None:
+            kwargs = {}
+        else:
+            kwargs = {"expr": structured_query.filter.accept(self)}
+        return structured_query.query, kwargs