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/supabase.py

@@ -0,0 +1,97 @@
+from typing import Any, Dict, Tuple
+
+from langchain_core.structured_query import (
+    Comparator,
+    Comparison,
+    Operation,
+    Operator,
+    StructuredQuery,
+    Visitor,
+)
+
+
+class SupabaseVectorTranslator(Visitor):
+    """Translate Langchain filters to Supabase PostgREST filters."""
+
+    allowed_operators = [Operator.AND, Operator.OR]
+    """Subset of allowed logical operators."""
+
+    allowed_comparators = [
+        Comparator.EQ,
+        Comparator.NE,
+        Comparator.GT,
+        Comparator.GTE,
+        Comparator.LT,
+        Comparator.LTE,
+        Comparator.LIKE,
+    ]
+    """Subset of allowed logical comparators."""
+
+    metadata_column = "metadata"
+
+    def _map_comparator(self, comparator: Comparator) -> str:
+        """
+        Maps Langchain comparator to PostgREST comparator:
+
+        https://postgrest.org/en/stable/references/api/tables_views.html#operators
+        """
+        postgrest_comparator = {
+            Comparator.EQ: "eq",
+            Comparator.NE: "neq",
+            Comparator.GT: "gt",
+            Comparator.GTE: "gte",
+            Comparator.LT: "lt",
+            Comparator.LTE: "lte",
+            Comparator.LIKE: "like",
+        }.get(comparator)
+
+        if postgrest_comparator is None:
+            raise Exception(
+                f"Comparator '{comparator}' is not currently "
+                "supported in Supabase Vector"
+            )
+
+        return postgrest_comparator
+
+    def _get_json_operator(self, value: Any) -> str:
+        if isinstance(value, str):
+            return "->>"
+        else:
+            return "->"
+
+    def visit_operation(self, operation: Operation) -> str:
+        args = [arg.accept(self) for arg in operation.arguments]
+        return f"{operation.operator.value}({','.join(args)})"
+
+    def visit_comparison(self, comparison: Comparison) -> str:
+        if isinstance(comparison.value, list):
+            return self.visit_operation(
+                Operation(
+                    operator=Operator.AND,
+                    arguments=[
+                        Comparison(
+                            comparator=comparison.comparator,
+                            attribute=comparison.attribute,
+                            value=value,
+                        )
+                        for value in comparison.value
+                    ],
+                )
+            )
+
+        return ".".join(
+            [
+                f"{self.metadata_column}{self._get_json_operator(comparison.value)}{comparison.attribute}",
+                f"{self._map_comparator(comparison.comparator)}",
+                f"{comparison.value}",
+            ]
+        )
+
+    def visit_structured_query(
+        self, structured_query: StructuredQuery
+    ) -> Tuple[str, Dict[str, str]]:
+        if structured_query.filter is None:
+            kwargs = {}
+        else:
+            kwargs = {"postgrest_filter": structured_query.filter.accept(self)}
+        return structured_query.query, kwargs