pytest-databases 0.4.1__tar.gz → 0.5.0__tar.gz

{pytest_databases-0.4.1 → pytest_databases-0.5.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pytest-databases
-Version: 0.4.1
+Version: 0.5.0
 Summary: Reusable database fixtures for any and all databases.
 Project-URL: Documentation, https://github.com/litestar-org/pytest-databases#readme
 Project-URL: Issues, https://github.com/litestar-org/pytest-databases/issues

{pytest_databases-0.4.1 → pytest_databases-0.5.0}/pyproject.toml

@@ -12,7 +12,7 @@ license = "MIT"
 name = "pytest-databases"
 readme = "README.md"
 requires-python = ">=3.8"
-version = "0.4.1"
+version = "0.5.0"
 #
 authors = [{ name = "Cody Fincher", email = "cody.fincher@gmail.com" }]
 keywords = [

{pytest_databases-0.4.1 → pytest_databases-0.5.0}/src/pytest_databases/docker/__init__.py

@@ -130,25 +130,3 @@ class DockerServiceRegistry:
     def down(self) -> None:
         if not SKIP_DOCKER_COMPOSE:
             self.run_command("down", "-t", "10")
-
-
-@pytest.fixture(scope="session")
-def compose_project_name() -> str:
-    return os.environ.get("COMPOSE_PROJECT_NAME", COMPOSE_PROJECT_NAME)
-
-
-@pytest.fixture(scope="session")
-def docker_services(compose_project_name: str, worker_id: str = "main") -> Generator[DockerServiceRegistry, None, None]:
-    if os.getenv("GITHUB_ACTIONS") == "true" and sys.platform != "linux":
-        pytest.skip("Docker not available on this platform")
-
-    registry = DockerServiceRegistry(worker_id, compose_project_name=compose_project_name)
-    try:
-        yield registry
-    finally:
-        registry.down()
-
-
-@pytest.fixture(scope="session")
-def docker_ip(docker_services: DockerServiceRegistry) -> str:
-    return docker_services.docker_ip

{pytest_databases-0.4.1 → pytest_databases-0.5.0}/src/pytest_databases/docker/alloydb_omni.py

@@ -24,14 +24,21 @@
 from __future__ import annotations
 
 import os
+import sys
 from pathlib import Path
-from typing import TYPE_CHECKING
+from typing import TYPE_CHECKING, AsyncGenerator
 
 import asyncpg
 import pytest
 
+from pytest_databases.docker import DockerServiceRegistry
+from pytest_databases.helpers import simple_string_hash
+
 if TYPE_CHECKING:
-    from pytest_databases.docker import DockerServiceRegistry
+    from collections.abc import Generator
+
+
+COMPOSE_PROJECT_NAME: str = f"pytest-databases-alloydb-{simple_string_hash(__file__)}"
 
 
 async def alloydb_omni_responsive(host: str, port: int, user: str, password: str, database: str) -> bool:
@@ -53,54 +60,78 @@ async def alloydb_omni_responsive(host: str, port: int, user: str, password: str
         await conn.close()
 
 
-@pytest.fixture()
+@pytest.fixture(scope="session")
+def alloydb_compose_project_name() -> str:
+    return os.environ.get("COMPOSE_PROJECT_NAME", COMPOSE_PROJECT_NAME)
+
+
+@pytest.fixture(autouse=False, scope="session")
+def alloydb_docker_services(
+    alloydb_compose_project_name: str, worker_id: str = "main"
+) -> Generator[DockerServiceRegistry, None, None]:
+    if os.getenv("GITHUB_ACTIONS") == "true" and sys.platform != "linux":
+        pytest.skip("Docker not available on this platform")
+
+    registry = DockerServiceRegistry(worker_id, compose_project_name=alloydb_compose_project_name)
+    try:
+        yield registry
+    finally:
+        registry.down()
+
+
+@pytest.fixture(scope="session")
 def postgres_user() -> str:
     return "postgres"
 
 
-@pytest.fixture()
+@pytest.fixture(scope="session")
 def postgres_password() -> str:
     return "super-secret"
 
 
-@pytest.fixture()
+@pytest.fixture(scope="session")
 def postgres_database() -> str:
     return "postgres"
 
 
-@pytest.fixture()
+@pytest.fixture(scope="session")
 def alloydb_omni_port() -> int:
     return 5420
 
 
-@pytest.fixture()
+@pytest.fixture(scope="session")
 def default_alloydb_omni_service_name() -> str:
     return "alloydb"
 
 
 @pytest.fixture(scope="session")
-def docker_compose_files() -> list[Path]:
+def alloydb_docker_compose_files() -> list[Path]:
     return [Path(Path(__file__).parent / "docker-compose.alloydb-omni.yml")]
 
 
+@pytest.fixture(scope="session")
+def alloydb_docker_ip(alloydb_docker_services: DockerServiceRegistry) -> str:
+    return alloydb_docker_services.docker_ip
+
+
 # alias to the latest
-@pytest.fixture(autouse=False)
+@pytest.fixture(autouse=False, scope="session")
 async def alloydb_omni_service(
-    docker_services: DockerServiceRegistry,
+    alloydb_docker_services: DockerServiceRegistry,
     default_alloydb_omni_service_name: str,
-    docker_compose_files: list[Path],
+    alloydb_docker_compose_files: list[Path],
     alloydb_omni_port: int,
     postgres_database: str,
     postgres_user: str,
     postgres_password: str,
-) -> None:
+) -> AsyncGenerator[None, None]:
     os.environ["POSTGRES_PASSWORD"] = postgres_password
     os.environ["POSTGRES_USER"] = postgres_user
     os.environ["POSTGRES_DATABASE"] = postgres_database
     os.environ[f"{default_alloydb_omni_service_name.upper()}_PORT"] = str(alloydb_omni_port)
-    await docker_services.start(
+    await alloydb_docker_services.start(
         name=default_alloydb_omni_service_name,
-        docker_compose_files=docker_compose_files,
+        docker_compose_files=alloydb_docker_compose_files,
         timeout=45,
         pause=1,
         check=alloydb_omni_responsive,
@@ -109,3 +140,4 @@ async def alloydb_omni_service(
         user=postgres_user,
         password=postgres_password,
     )
+    yield

{pytest_databases-0.4.1 → pytest_databases-0.5.0}/src/pytest_databases/docker/bigquery.py

@@ -24,16 +24,23 @@
 from __future__ import annotations
 
 import os
+import sys
 from pathlib import Path
-from typing import TYPE_CHECKING
+from typing import TYPE_CHECKING, AsyncGenerator
 
 import pytest
 from google.api_core.client_options import ClientOptions
 from google.auth.credentials import AnonymousCredentials, Credentials
 from google.cloud import bigquery
 
+from pytest_databases.docker import DockerServiceRegistry
+from pytest_databases.helpers import simple_string_hash
+
 if TYPE_CHECKING:
-    from pytest_databases.docker import DockerServiceRegistry
+    from collections.abc import Generator
+
+
+COMPOSE_PROJECT_NAME: str = f"pytest-databases-bigquery-{simple_string_hash(__file__)}"
 
 
 async def bigquery_responsive(
@@ -57,43 +64,57 @@ async def bigquery_responsive(
         return False
 
 
-@pytest.fixture
+@pytest.fixture(scope="session")
+def bigquery_compose_project_name() -> str:
+    return os.environ.get("COMPOSE_PROJECT_NAME", COMPOSE_PROJECT_NAME)
+
+
+@pytest.fixture(autouse=False, scope="session")
+def bigquery_docker_services(
+    bigquery_compose_project_name: str, worker_id: str = "main"
+) -> Generator[DockerServiceRegistry, None, None]:
+    if os.getenv("GITHUB_ACTIONS") == "true" and sys.platform != "linux":
+        pytest.skip("Docker not available on this platform")
+
+    registry = DockerServiceRegistry(worker_id, compose_project_name=bigquery_compose_project_name)
+    try:
+        yield registry
+    finally:
+        registry.down()
+
+
+@pytest.fixture(scope="session")
 def bigquery_port() -> int:
     return 9051
 
 
-@pytest.fixture
+@pytest.fixture(scope="session")
 def bigquery_grpc_port() -> int:
     return 9061
 
 
-@pytest.fixture
-def bigquery_endpoint(docker_ip: str, bigquery_port: int) -> str:
-    return f"http://{docker_ip}:{bigquery_port}"
-
-
-@pytest.fixture
+@pytest.fixture(scope="session")
 def bigquery_dataset() -> str:
     return "test-dataset"
 
 
-@pytest.fixture
+@pytest.fixture(scope="session")
 def bigquery_project() -> str:
     return "emulator-test-project"
 
 
-@pytest.fixture()
+@pytest.fixture(scope="session")
 def bigquery_client_options(bigquery_endpoint: str) -> ClientOptions:
     return ClientOptions(api_endpoint=bigquery_endpoint)
 
 
-@pytest.fixture
+@pytest.fixture(scope="session")
 def bigquery_credentials() -> Credentials:
     return AnonymousCredentials()
 
 
 @pytest.fixture(scope="session")
-def docker_compose_files() -> list[Path]:
+def bigquery_docker_compose_files() -> list[Path]:
     return [Path(Path(__file__).parent / "docker-compose.bigquery.yml")]
 
 
@@ -102,11 +123,21 @@ def default_bigquery_service_name() -> str:
     return "bigquery"
 
 
-@pytest.fixture(autouse=False)
+@pytest.fixture(scope="session")
+def bigquery_docker_ip(bigquery_docker_services: DockerServiceRegistry) -> str:
+    return bigquery_docker_services.docker_ip
+
+
+@pytest.fixture(scope="session")
+def bigquery_endpoint(bigquery_docker_ip: str, bigquery_port: int) -> str:
+    return f"http://{bigquery_docker_ip}:{bigquery_port}"
+
+
+@pytest.fixture(autouse=False, scope="session")
 async def bigquery_service(
-    docker_services: DockerServiceRegistry,
+    bigquery_docker_services: DockerServiceRegistry,
     default_bigquery_service_name: str,
-    docker_compose_files: list[Path],
+    bigquery_docker_compose_files: list[Path],
     bigquery_port: int,
     bigquery_grpc_port: int,
     bigquery_endpoint: str,
@@ -114,15 +145,15 @@ async def bigquery_service(
     bigquery_project: str,
     bigquery_credentials: Credentials,
     bigquery_client_options: ClientOptions,
-) -> None:
+) -> AsyncGenerator[None, None]:
     os.environ["BIGQUERY_ENDPOINT"] = bigquery_endpoint
     os.environ["BIGQUERY_DATASET"] = bigquery_dataset
     os.environ["BIGQUERY_PORT"] = str(bigquery_port)
     os.environ["BIGQUERY_GRPC_PORT"] = str(bigquery_grpc_port)
     os.environ["GOOGLE_CLOUD_PROJECT"] = bigquery_project
-    await docker_services.start(
+    await bigquery_docker_services.start(
         name=default_bigquery_service_name,
-        docker_compose_files=docker_compose_files,
+        docker_compose_files=bigquery_docker_compose_files,
         timeout=60,
         check=bigquery_responsive,
         bigquery_endpoint=bigquery_endpoint,
@@ -131,3 +162,4 @@ async def bigquery_service(
         bigquery_credentials=bigquery_credentials,
         bigquery_client_options=bigquery_client_options,
     )
+    yield

{pytest_databases-0.4.1 → pytest_databases-0.5.0}/src/pytest_databases/docker/cockroachdb.py

@@ -23,14 +23,21 @@
 from __future__ import annotations
 
 import os
+import sys
 from pathlib import Path
-from typing import TYPE_CHECKING
+from typing import TYPE_CHECKING, AsyncGenerator
 
 import psycopg
 import pytest
 
+from pytest_databases.docker import DockerServiceRegistry
+from pytest_databases.helpers import simple_string_hash
+
 if TYPE_CHECKING:
-    from pytest_databases.docker import DockerServiceRegistry
+    from collections.abc import Generator
+
+
+COMPOSE_PROJECT_NAME: str = f"pytest-databases-cockroachdb-{simple_string_hash(__file__)}"
 
 
 async def cockroachdb_responsive(host: str, port: int, database: str, driver_opts: dict[str, str]) -> bool:
@@ -44,23 +51,42 @@ async def cockroachdb_responsive(host: str, port: int, database: str, driver_opt
         return False
 
 
-@pytest.fixture()
+@pytest.fixture(scope="session")
+def cockroachdb_compose_project_name() -> str:
+    return os.environ.get("COMPOSE_PROJECT_NAME", COMPOSE_PROJECT_NAME)
+
+
+@pytest.fixture(autouse=False, scope="session")
+def cockroachdb_docker_services(
+    cockroachdb_compose_project_name: str, worker_id: str = "main"
+) -> Generator[DockerServiceRegistry, None, None]:
+    if os.getenv("GITHUB_ACTIONS") == "true" and sys.platform != "linux":
+        pytest.skip("Docker not available on this platform")
+
+    registry = DockerServiceRegistry(worker_id, compose_project_name=cockroachdb_compose_project_name)
+    try:
+        yield registry
+    finally:
+        registry.down()
+
+
+@pytest.fixture(scope="session")
 def cockroachdb_port() -> int:
     return 26257
 
 
-@pytest.fixture()
+@pytest.fixture(scope="session")
 def cockroachdb_database() -> str:
     return "defaultdb"
 
 
-@pytest.fixture()
+@pytest.fixture(scope="session")
 def cockroachdb_driver_opts() -> dict[str, str]:
     return {"sslmode": "disable"}
 
 
 @pytest.fixture(scope="session")
-def docker_compose_files() -> list[Path]:
+def cockroachdb_docker_compose_files() -> list[Path]:
     return [Path(Path(__file__).parent / "docker-compose.cockroachdb.yml")]
 
 
@@ -69,20 +95,25 @@ def default_cockroachdb_service_name() -> str:
     return "cockroachdb"
 
 
-@pytest.fixture(autouse=False)
+@pytest.fixture(scope="session")
+def cockroachdb_docker_ip(cockroachdb_docker_services: DockerServiceRegistry) -> str:
+    return cockroachdb_docker_services.docker_ip
+
+
+@pytest.fixture(autouse=False, scope="session")
 async def cockroachdb_service(
-    docker_services: DockerServiceRegistry,
+    cockroachdb_docker_services: DockerServiceRegistry,
     default_cockroachdb_service_name: str,
-    docker_compose_files: list[Path],
+    cockroachdb_docker_compose_files: list[Path],
     cockroachdb_port: int,
     cockroachdb_database: str,
     cockroachdb_driver_opts: dict[str, str],
-) -> None:
+) -> AsyncGenerator[None, None]:
     os.environ["COCKROACHDB_DATABASE"] = cockroachdb_database
     os.environ["COCKROACHDB_PORT"] = str(cockroachdb_port)
-    await docker_services.start(
+    await cockroachdb_docker_services.start(
         name=default_cockroachdb_service_name,
-        docker_compose_files=docker_compose_files,
+        docker_compose_files=cockroachdb_docker_compose_files,
         timeout=60,
         pause=1,
         check=cockroachdb_responsive,
@@ -90,3 +121,4 @@ async def cockroachdb_service(
         database=cockroachdb_database,
         driver_opts=cockroachdb_driver_opts,
     )
+    yield

{pytest_databases-0.4.1 → pytest_databases-0.5.0}/src/pytest_databases/docker/dragonfly.py

@@ -24,15 +24,21 @@
 from __future__ import annotations
 
 import os
+import sys
 from pathlib import Path
-from typing import TYPE_CHECKING
+from typing import TYPE_CHECKING, AsyncGenerator
 
 import pytest
 from redis.asyncio import Redis as AsyncRedis
 from redis.exceptions import ConnectionError as RedisConnectionError
 
+from pytest_databases.docker import DockerServiceRegistry
+from pytest_databases.helpers import simple_string_hash
+
 if TYPE_CHECKING:
-    from pytest_databases.docker import DockerServiceRegistry
+    from collections.abc import Generator
+
+COMPOSE_PROJECT_NAME: str = f"pytest-databases-dragonfly-{simple_string_hash(__file__)}"
 
 
 async def dragonfly_responsive(host: str, port: int) -> bool:
@@ -45,13 +51,32 @@ async def dragonfly_responsive(host: str, port: int) -> bool:
         await client.aclose()  # type: ignore[attr-defined]
 
 
-@pytest.fixture()
+@pytest.fixture(scope="session")
+def dragonfly_compose_project_name() -> str:
+    return os.environ.get("COMPOSE_PROJECT_NAME", COMPOSE_PROJECT_NAME)
+
+
+@pytest.fixture(autouse=False, scope="session")
+def dragonfly_docker_services(
+    dragonfly_compose_project_name: str, worker_id: str = "main"
+) -> Generator[DockerServiceRegistry, None, None]:
+    if os.getenv("GITHUB_ACTIONS") == "true" and sys.platform != "linux":
+        pytest.skip("Docker not available on this platform")
+
+    registry = DockerServiceRegistry(worker_id, compose_project_name=dragonfly_compose_project_name)
+    try:
+        yield registry
+    finally:
+        registry.down()
+
+
+@pytest.fixture(scope="session")
 def dragonfly_port() -> int:
     return 6398
 
 
 @pytest.fixture(scope="session")
-def docker_compose_files() -> list[Path]:
+def dragonfly_docker_compose_files() -> list[Path]:
     return [Path(Path(__file__).parent / "docker-compose.dragonfly.yml")]
 
 
@@ -60,17 +85,23 @@ def default_dragonfly_service_name() -> str:
     return "dragonfly"
 
 
-@pytest.fixture(autouse=False)
+@pytest.fixture(scope="session")
+def dragonfly_docker_ip(dragonfly_docker_services: DockerServiceRegistry) -> str:
+    return dragonfly_docker_services.docker_ip
+
+
+@pytest.fixture(autouse=False, scope="session")
 async def dragonfly_service(
-    docker_services: DockerServiceRegistry,
+    dragonfly_docker_services: DockerServiceRegistry,
     default_dragonfly_service_name: str,
-    docker_compose_files: list[Path],
+    dragonfly_docker_compose_files: list[Path],
     dragonfly_port: int,
-) -> None:
+) -> AsyncGenerator[None, None]:
     os.environ["DRAGONFLY_PORT"] = str(dragonfly_port)
-    await docker_services.start(
+    await dragonfly_docker_services.start(
         name=default_dragonfly_service_name,
-        docker_compose_files=docker_compose_files,
+        docker_compose_files=dragonfly_docker_compose_files,
         check=dragonfly_responsive,
         port=dragonfly_port,
     )
+    yield

{pytest_databases-0.4.1 → pytest_databases-0.5.0}/src/pytest_databases/docker/elastic_search.py

@@ -23,15 +23,23 @@
 
 from __future__ import annotations
 
+import os
+import sys
 from pathlib import Path
-from typing import TYPE_CHECKING
+from typing import TYPE_CHECKING, AsyncGenerator
 
 import pytest
 from elasticsearch7 import AsyncElasticsearch as Elasticsearch7
 from elasticsearch7 import AsyncElasticsearch as Elasticsearch8
 
+from pytest_databases.docker import DockerServiceRegistry
+from pytest_databases.helpers import simple_string_hash
+
 if TYPE_CHECKING:
-    from pytest_databases.docker import DockerServiceRegistry
+    from collections.abc import Generator
+
+
+COMPOSE_PROJECT_NAME: str = f"pytest-databases-elasticsearch-{simple_string_hash(__file__)}"
 
 
 async def elasticsearch7_responsive(scheme: str, host: str, port: int, user: str, password: str, database: str) -> bool:
@@ -54,38 +62,57 @@ async def elasticsearch8_responsive(scheme: str, host: str, port: int, user: str
         return False
 
 
-@pytest.fixture
+@pytest.fixture(scope="session")
+def elasticsearch_compose_project_name() -> str:
+    return os.environ.get("COMPOSE_PROJECT_NAME", COMPOSE_PROJECT_NAME)
+
+
+@pytest.fixture(autouse=False, scope="session")
+def elasticsearch_docker_services(
+    elasticsearch_compose_project_name: str, worker_id: str = "main"
+) -> Generator[DockerServiceRegistry, None, None]:
+    if os.getenv("GITHUB_ACTIONS") == "true" and sys.platform != "linux":
+        pytest.skip("Docker not available on this platform")
+
+    registry = DockerServiceRegistry(worker_id, compose_project_name=elasticsearch_compose_project_name)
+    try:
+        yield registry
+    finally:
+        registry.down()
+
+
+@pytest.fixture(scope="session")
 def elasticsearch_user() -> str:
     return "elastic"
 
 
-@pytest.fixture
+@pytest.fixture(scope="session")
 def elasticsearch_password() -> str:
     return "changeme"
 
 
-@pytest.fixture
+@pytest.fixture(scope="session")
 def elasticsearch_database() -> str:
     return "db"
 
 
-@pytest.fixture
+@pytest.fixture(scope="session")
 def elasticsearch_scheme() -> str:
     return "http"
 
 
-@pytest.fixture
+@pytest.fixture(scope="session")
 def elasticsearch7_port() -> int:
     return 9200
 
 
-@pytest.fixture
+@pytest.fixture(scope="session")
 def elasticsearch8_port() -> int:
     return 9201
 
 
 @pytest.fixture(scope="session")
-def docker_compose_files() -> list[Path]:
+def elasticsearch_docker_compose_files() -> list[Path]:
     return [Path(Path(__file__).parent / "docker-compose.elasticsearch.yml")]
 
 
@@ -94,19 +121,24 @@ def default_elasticsearch_service_name() -> str:
     return "elasticsearch8"
 
 
-@pytest.fixture(autouse=False)
+@pytest.fixture(scope="session")
+def elasticsearch_docker_ip(elasticsearch_docker_services: DockerServiceRegistry) -> str:
+    return elasticsearch_docker_services.docker_ip
+
+
+@pytest.fixture(autouse=False, scope="session")
 async def elasticsearch7_service(
-    docker_services: DockerServiceRegistry,
-    docker_compose_files: list[Path],
+    elasticsearch_docker_services: DockerServiceRegistry,
+    elasticsearch_docker_compose_files: list[Path],
     elasticsearch7_port: int,
     elasticsearch_database: str,
     elasticsearch_user: str,
     elasticsearch_password: str,
     elasticsearch_scheme: str,
-) -> None:
-    await docker_services.start(
+) -> AsyncGenerator[None, None]:
+    await elasticsearch_docker_services.start(
         "elasticsearch7",
-        docker_compose_files=docker_compose_files,
+        docker_compose_files=elasticsearch_docker_compose_files,
         timeout=45,
         pause=1,
         check=elasticsearch7_responsive,
@@ -116,21 +148,22 @@ async def elasticsearch7_service(
         password=elasticsearch_password,
         scheme=elasticsearch_scheme,
     )
+    yield
 
 
-@pytest.fixture(autouse=False)
+@pytest.fixture(autouse=False, scope="session")
 async def elasticsearch8_service(
-    docker_services: DockerServiceRegistry,
-    docker_compose_files: list[Path],
+    elasticsearch_docker_services: DockerServiceRegistry,
+    elasticsearch_docker_compose_files: list[Path],
     elasticsearch8_port: int,
     elasticsearch_database: str,
     elasticsearch_user: str,
     elasticsearch_password: str,
     elasticsearch_scheme: str,
-) -> None:
-    await docker_services.start(
+) -> AsyncGenerator[None, None]:
+    await elasticsearch_docker_services.start(
         "elasticsearch8",
-        docker_compose_files=docker_compose_files,
+        docker_compose_files=elasticsearch_docker_compose_files,
         timeout=45,
         pause=1,
         check=elasticsearch8_responsive,
@@ -140,22 +173,23 @@ async def elasticsearch8_service(
         password=elasticsearch_password,
         scheme=elasticsearch_scheme,
     )
+    yield
 
 
-@pytest.fixture(autouse=False)
+@pytest.fixture(autouse=False, scope="session")
 async def elasticsearch_service(
-    docker_services: DockerServiceRegistry,
+    elasticsearch_docker_services: DockerServiceRegistry,
     default_elasticsearch_service_name: str,
-    docker_compose_files: list[Path],
+    elasticsearch_docker_compose_files: list[Path],
     elasticsearch8_port: int,
     elasticsearch_database: str,
     elasticsearch_user: str,
     elasticsearch_password: str,
     elasticsearch_scheme: str,
-) -> None:
-    await docker_services.start(
+) -> AsyncGenerator[None, None]:
+    await elasticsearch_docker_services.start(
         name=default_elasticsearch_service_name,
-        docker_compose_files=docker_compose_files,
+        docker_compose_files=elasticsearch_docker_compose_files,
         timeout=45,
         pause=1,
         check=elasticsearch8_responsive,
@@ -165,3 +199,4 @@ async def elasticsearch_service(
         password=elasticsearch_password,
         scheme=elasticsearch_scheme,
     )
+    yield