standard-tests: Add ruff rule UP (pyupgrade) (#31842)

See https://docs.astral.sh/ruff/rules/#pyupgrade-up
All auto-fixed

Author: cbornet

libs/standard-tests/langchain_tests/base.py

@@ -1,5 +1,4 @@
 from abc import ABC
-from typing import Type
 
 
 class BaseStandardTests(ABC):
@@ -16,7 +15,7 @@ def test_no_overrides_DO_NOT_OVERRIDE(self) -> None:
         # find path to standard test implementations
         comparison_class = None
 
-        def explore_bases(cls: Type) -> None:
+        def explore_bases(cls: type) -> None:
             nonlocal comparison_class
             for base in cls.__bases__:
                 if base.__module__.startswith("langchain_tests."):

libs/standard-tests/langchain_tests/integration_tests/base_store.py

@@ -7,7 +7,8 @@
 """
 
 from abc import abstractmethod
-from typing import AsyncGenerator, Generator, Generic, Tuple, TypeVar
+from collections.abc import AsyncGenerator, Generator
+from typing import Generic, TypeVar
 
 import pytest
 from langchain_core.stores import BaseStore
@@ -38,11 +39,11 @@ def kv_store(self) -> BaseStore[str, V]:
 
     @abstractmethod
     @pytest.fixture()
-    def three_values(self) -> Tuple[V, V, V]:
+    def three_values(self) -> tuple[V, V, V]:
         """Three example values that will be used in the tests."""
         pass
 
-    def test_three_values(self, three_values: Tuple[V, V, V]) -> None:
+    def test_three_values(self, three_values: tuple[V, V, V]) -> None:
         """Test that the fixture provides three values."""
         assert isinstance(three_values, tuple)
         assert len(three_values) == 3
@@ -53,7 +54,7 @@ def test_kv_store_is_empty(self, kv_store: BaseStore[str, V]) -> None:
         assert kv_store.mget(keys) == [None, None, None]
 
     def test_set_and_get_values(
-        self, kv_store: BaseStore[str, V], three_values: Tuple[V, V, V]
+        self, kv_store: BaseStore[str, V], three_values: tuple[V, V, V]
     ) -> None:
         """Test setting and getting values in the key-value store."""
         foo = three_values[0]
@@ -72,7 +73,7 @@ def test_store_still_empty(self, kv_store: BaseStore[str, V]) -> None:
         assert kv_store.mget(keys) == [None]
 
     def test_delete_values(
-        self, kv_store: BaseStore[str, V], three_values: Tuple[V, V, V]
+        self, kv_store: BaseStore[str, V], three_values: tuple[V, V, V]
     ) -> None:
         """Test deleting values from the key-value store."""
         foo = three_values[0]
@@ -83,7 +84,7 @@ def test_delete_values(
         assert kv_store.mget(["foo", "bar"]) == [None, bar]
 
     def test_delete_bulk_values(
-        self, kv_store: BaseStore[str, V], three_values: Tuple[V, V, V]
+        self, kv_store: BaseStore[str, V], three_values: tuple[V, V, V]
     ) -> None:
         """Test that we can delete several values at once."""
         foo, bar, buz = three_values
@@ -98,7 +99,7 @@ def test_delete_missing_keys(self, kv_store: BaseStore[str, V]) -> None:
         kv_store.mdelete(["foo", "bar", "baz"])
 
     def test_set_values_is_idempotent(
-        self, kv_store: BaseStore[str, V], three_values: Tuple[V, V, V]
+        self, kv_store: BaseStore[str, V], three_values: tuple[V, V, V]
     ) -> None:
         """Setting values by key should be idempotent."""
         foo, bar, _ = three_values
@@ -109,7 +110,7 @@ def test_set_values_is_idempotent(
         assert sorted(kv_store.yield_keys()) == ["bar", "foo"]
 
     def test_get_can_get_same_value(
-        self, kv_store: BaseStore[str, V], three_values: Tuple[V, V, V]
+        self, kv_store: BaseStore[str, V], three_values: tuple[V, V, V]
     ) -> None:
         """Test that the same value can be retrieved multiple times."""
         foo, bar, _ = three_values
@@ -119,7 +120,7 @@ def test_get_can_get_same_value(
         assert kv_store.mget(["foo", "bar", "foo", "bar"]) == [foo, bar, foo, bar]
 
     def test_overwrite_values_by_key(
-        self, kv_store: BaseStore[str, V], three_values: Tuple[V, V, V]
+        self, kv_store: BaseStore[str, V], three_values: tuple[V, V, V]
     ) -> None:
         """Test that we can overwrite values by key using mset."""
         foo, bar, buzz = three_values
@@ -134,7 +135,7 @@ def test_overwrite_values_by_key(
         assert kv_store.mget(["foo", "bar"]) == [buzz, bar]
 
     def test_yield_keys(
-        self, kv_store: BaseStore[str, V], three_values: Tuple[V, V, V]
+        self, kv_store: BaseStore[str, V], three_values: tuple[V, V, V]
     ) -> None:
         """Test that we can yield keys from the store."""
         foo, bar, _buzz = three_values
@@ -169,11 +170,11 @@ async def kv_store(self) -> BaseStore[str, V]:
 
     @abstractmethod
     @pytest.fixture()
-    def three_values(self) -> Tuple[V, V, V]:
+    def three_values(self) -> tuple[V, V, V]:
         """Three example values that will be used in the tests."""
         pass
 
-    async def test_three_values(self, three_values: Tuple[V, V, V]) -> None:
+    async def test_three_values(self, three_values: tuple[V, V, V]) -> None:
         """Test that the fixture provides three values."""
         assert isinstance(three_values, tuple)
         assert len(three_values) == 3
@@ -184,7 +185,7 @@ async def test_kv_store_is_empty(self, kv_store: BaseStore[str, V]) -> None:
         assert await kv_store.amget(keys) == [None, None, None]
 
     async def test_set_and_get_values(
-        self, kv_store: BaseStore[str, V], three_values: Tuple[V, V, V]
+        self, kv_store: BaseStore[str, V], three_values: tuple[V, V, V]
     ) -> None:
         """Test setting and getting values in the key-value store."""
         foo = three_values[0]
@@ -203,7 +204,7 @@ async def test_store_still_empty(self, kv_store: BaseStore[str, V]) -> None:
         assert await kv_store.amget(keys) == [None]
 
     async def test_delete_values(
-        self, kv_store: BaseStore[str, V], three_values: Tuple[V, V, V]
+        self, kv_store: BaseStore[str, V], three_values: tuple[V, V, V]
     ) -> None:
         """Test deleting values from the key-value store."""
         foo = three_values[0]
@@ -214,7 +215,7 @@ async def test_delete_values(
         assert await kv_store.amget(["foo", "bar"]) == [None, bar]
 
     async def test_delete_bulk_values(
-        self, kv_store: BaseStore[str, V], three_values: Tuple[V, V, V]
+        self, kv_store: BaseStore[str, V], three_values: tuple[V, V, V]
     ) -> None:
         """Test that we can delete several values at once."""
         foo, bar, buz = three_values
@@ -229,7 +230,7 @@ async def test_delete_missing_keys(self, kv_store: BaseStore[str, V]) -> None:
         await kv_store.amdelete(["foo", "bar", "baz"])
 
     async def test_set_values_is_idempotent(
-        self, kv_store: BaseStore[str, V], three_values: Tuple[V, V, V]
+        self, kv_store: BaseStore[str, V], three_values: tuple[V, V, V]
     ) -> None:
         """Setting values by key should be idempotent."""
         foo, bar, _ = three_values
@@ -240,7 +241,7 @@ async def test_set_values_is_idempotent(
         assert sorted(kv_store.yield_keys()) == ["bar", "foo"]
 
     async def test_get_can_get_same_value(
-        self, kv_store: BaseStore[str, V], three_values: Tuple[V, V, V]
+        self, kv_store: BaseStore[str, V], three_values: tuple[V, V, V]
     ) -> None:
         """Test that the same value can be retrieved multiple times."""
         foo, bar, _ = three_values
@@ -255,7 +256,7 @@ async def test_get_can_get_same_value(
         ]
 
     async def test_overwrite_values_by_key(
-        self, kv_store: BaseStore[str, V], three_values: Tuple[V, V, V]
+        self, kv_store: BaseStore[str, V], three_values: tuple[V, V, V]
     ) -> None:
         """Test that we can overwrite values by key using mset."""
         foo, bar, buzz = three_values
@@ -270,7 +271,7 @@ async def test_overwrite_values_by_key(
         assert await kv_store.amget(["foo", "bar"]) == [buzz, bar]
 
     async def test_yield_keys(
-        self, kv_store: BaseStore[str, V], three_values: Tuple[V, V, V]
+        self, kv_store: BaseStore[str, V], three_values: tuple[V, V, V]
     ) -> None:
         """Test that we can yield keys from the store."""
         foo, bar, _buzz = three_values

libs/standard-tests/langchain_tests/integration_tests/chat_models.py

@@ -1,7 +1,7 @@
 import base64
 import inspect
 import json
-from typing import Any, List, Literal, Optional, cast
+from typing import Annotated, Any, Literal, Optional, cast
 from unittest.mock import MagicMock
 
 import httpx
@@ -29,7 +29,7 @@
 from pydantic.v1 import BaseModel as BaseModelV1
 from pydantic.v1 import Field as FieldV1
 from pytest_benchmark.fixture import BenchmarkFixture  # type: ignore[import-untyped]
-from typing_extensions import Annotated, TypedDict
+from typing_extensions import TypedDict
 from vcr.cassette import Cassette
 
 from langchain_tests.unit_tests.chat_models import (
@@ -2680,7 +2680,7 @@ def supports_anthropic_inputs(self) -> bool:
             "cache_control": {"type": "ephemeral"},
         }
 
-        human_content: List[dict] = [
+        human_content: list[dict] = [
             {
                 "type": "text",
                 "text": "what's your favorite color in this image",

libs/standard-tests/langchain_tests/integration_tests/embeddings.py

@@ -1,5 +1,3 @@
-from typing import List
-
 from langchain_core.embeddings import Embeddings
 
 from langchain_tests.unit_tests.embeddings import EmbeddingsTests
@@ -49,7 +47,7 @@ def test_embed_query(self, model: Embeddings) -> None:
         """  # noqa: E501
         embedding_1 = model.embed_query("foo")
 
-        assert isinstance(embedding_1, List)
+        assert isinstance(embedding_1, list)
         assert isinstance(embedding_1[0], float)
 
         embedding_2 = model.embed_query("bar")
@@ -71,7 +69,7 @@ def test_embed_documents(self, model: Embeddings) -> None:
         embeddings = model.embed_documents(documents)
 
         assert len(embeddings) == len(documents)
-        assert all(isinstance(embedding, List) for embedding in embeddings)
+        assert all(isinstance(embedding, list) for embedding in embeddings)
         assert all(isinstance(embedding[0], float) for embedding in embeddings)
         assert len(embeddings[0]) > 0
         assert all(len(embedding) == len(embeddings[0]) for embedding in embeddings)
@@ -88,7 +86,7 @@ async def test_aembed_query(self, model: Embeddings) -> None:
         """  # noqa: E501
         embedding_1 = await model.aembed_query("foo")
 
-        assert isinstance(embedding_1, List)
+        assert isinstance(embedding_1, list)
         assert isinstance(embedding_1[0], float)
 
         embedding_2 = await model.aembed_query("bar")
@@ -110,7 +108,7 @@ async def test_aembed_documents(self, model: Embeddings) -> None:
         embeddings = await model.aembed_documents(documents)
 
         assert len(embeddings) == len(documents)
-        assert all(isinstance(embedding, List) for embedding in embeddings)
+        assert all(isinstance(embedding, list) for embedding in embeddings)
         assert all(isinstance(embedding[0], float) for embedding in embeddings)
         assert len(embeddings[0]) > 0
         assert all(len(embedding) == len(embeddings[0]) for embedding in embeddings)

libs/standard-tests/langchain_tests/integration_tests/indexer.py

@@ -11,7 +11,7 @@
 import inspect
 import uuid
 from abc import ABC, abstractmethod
-from typing import AsyncGenerator, Generator
+from collections.abc import AsyncGenerator, Generator
 
 import pytest
 from langchain_core.documents import Document

libs/standard-tests/langchain_tests/integration_tests/retrievers.py

@@ -1,5 +1,4 @@
 from abc import abstractmethod
-from typing import Type
 
 import pytest
 from langchain_core.documents import Document
@@ -15,7 +14,7 @@ class RetrieversIntegrationTests(BaseStandardTests):
 
     @property
     @abstractmethod
-    def retriever_constructor(self) -> Type[BaseRetriever]:
+    def retriever_constructor(self) -> type[BaseRetriever]:
         """
         A BaseRetriever subclass to be tested.
         """

libs/standard-tests/langchain_tests/unit_tests/chat_models.py

@@ -5,7 +5,7 @@
 import inspect
 import os
 from abc import abstractmethod
-from typing import Any, Dict, List, Literal, Optional, Tuple, Type
+from typing import Any, Literal, Optional
 from unittest import mock
 
 import pytest
@@ -78,7 +78,7 @@ class ChatModelTests(BaseStandardTests):
 
     @property
     @abstractmethod
-    def chat_model_class(self) -> Type[BaseChatModel]:
+    def chat_model_class(self) -> type[BaseChatModel]:
         """The chat model class to test, e.g., ``ChatParrotLink``."""
         ...
 
@@ -214,9 +214,9 @@ def enable_vcr_tests(self) -> bool:
     @property
     def supported_usage_metadata_details(
         self,
-    ) -> Dict[
+    ) -> dict[
         Literal["invoke", "stream"],
-        List[
+        list[
             Literal[
                 "audio_input",
                 "audio_output",
@@ -804,7 +804,7 @@ def standard_chat_model_params(self) -> dict:
         return params
 
     @property
-    def init_from_env_params(self) -> Tuple[dict, dict, dict]:
+    def init_from_env_params(self) -> tuple[dict, dict, dict]:
         """(tuple) environment variables, additional initialization args, and expected
         instance attributes for testing initialization from environment variables."""
         return {}, {}, {}
@@ -958,7 +958,7 @@ class ExpectedParams(BaseModelV1):
             ls_model_type: Literal["chat"]
             ls_temperature: Optional[float]
             ls_max_tokens: Optional[int]
-            ls_stop: Optional[List[str]]
+            ls_stop: Optional[list[str]]
 
         ls_params = model._get_ls_params()
         try:

libs/standard-tests/langchain_tests/unit_tests/embeddings.py

@@ -1,6 +1,5 @@
 import os
 from abc import abstractmethod
-from typing import Tuple, Type
 from unittest import mock
 
 import pytest
@@ -17,7 +16,7 @@ class EmbeddingsTests(BaseStandardTests):
 
     @property
     @abstractmethod
-    def embeddings_class(self) -> Type[Embeddings]: ...
+    def embeddings_class(self) -> type[Embeddings]: ...
 
     @property
     def embedding_model_params(self) -> dict:
@@ -103,7 +102,7 @@ def test_init(self) -> None:
         assert model is not None
 
     @property
-    def init_from_env_params(self) -> Tuple[dict, dict, dict]:
+    def init_from_env_params(self) -> tuple[dict, dict, dict]:
         """This property is used in unit tests to test initialization from environment
         variables. It should return a tuple of three dictionaries that specify the
         environment variables, additional initialization args, and expected instance

libs/standard-tests/langchain_tests/unit_tests/tools.py

@@ -1,6 +1,6 @@
 import os
 from abc import abstractmethod
-from typing import Tuple, Type, Union
+from typing import Union
 from unittest import mock
 
 import pytest
@@ -19,7 +19,7 @@ class ToolsTests(BaseStandardTests):
 
     @property
     @abstractmethod
-    def tool_constructor(self) -> Union[Type[BaseTool], BaseTool]:
+    def tool_constructor(self) -> Union[type[BaseTool], BaseTool]:
         """
         Returns a class or instance of a tool to be tested.
         """
@@ -64,7 +64,7 @@ class ToolsUnitTests(ToolsTests):
     """
 
     @property
-    def init_from_env_params(self) -> Tuple[dict, dict, dict]:
+    def init_from_env_params(self) -> tuple[dict, dict, dict]:
         """Return env vars, init args, and expected instance attrs for initializing
         from env vars."""
         return {}, {}, {}

libs/standard-tests/pyproject.toml

@@ -55,7 +55,8 @@ ignore_missing_imports = true
 target-version = "py39"
 
 [tool.ruff.lint]
-select = ["E", "F", "I", "T201"]
+select = ["E", "F", "I", "T201", "UP",]
+ignore = ["UP007",]
 
 [tool.coverage.run]
 omit = ["tests/*"]