merge msater into 6704-instrument-httpx-clients

Author: bisgaard-itis

api/specs/web-server/_folders.py

@@ -63,6 +63,28 @@ async def list_folders(
     ...
 
 
+@router.get(
+    "/folders:search",
+    response_model=Envelope[list[FolderGet]],
+)
+async def list_folders_full_search(
+    params: Annotated[PageQueryParameters, Depends()],
+    text: str | None = None,
+    order_by: Annotated[
+        Json,
+        Query(
+            description="Order by field (modified_at|name|description) and direction (asc|desc). The default sorting order is ascending.",
+            example='{"field": "name", "direction": "desc"}',
+        ),
+    ] = '{"field": "modified_at", "direction": "desc"}',
+    filters: Annotated[
+        Json | None,
+        Query(description=FolderFilters.schema_json(indent=1)),
+    ] = None,
+):
+    ...
+
+
 @router.get(
     "/folders/{folder_id}",
     response_model=Envelope[FolderGet],

packages/models-library/src/models_library/folders.py

@@ -4,6 +4,7 @@
 
 from pydantic import BaseModel, Field, PositiveInt, validator
 
+from .access_rights import AccessRights
 from .users import GroupID, UserID
 from .utils.enums import StrAutoEnum
 from .workspaces import WorkspaceID
@@ -66,3 +67,10 @@ class FolderDB(BaseModel):
 
     class Config:
         orm_mode = True
+
+
+class UserFolderAccessRightsDB(FolderDB):
+    my_access_rights: AccessRights
+
+    class Config:
+        orm_mode = True

packages/postgres-database/src/simcore_postgres_database/utils_sql.py

@@ -0,0 +1,6 @@
+def assemble_array_groups(user_group_ids: list[int]) -> str:
+    return (
+        "array[]::text[]"
+        if len(user_group_ids) == 0
+        else f"""array[{', '.join(f"'{group_id}'" for group_id in user_group_ids)}]"""
+    )

packages/postgres-database/src/simcore_postgres_database/utils_workspaces_sql.py

@@ -0,0 +1,30 @@
+from simcore_postgres_database.models.groups import user_to_groups
+from simcore_postgres_database.models.workspaces_access_rights import (
+    workspaces_access_rights,
+)
+from sqlalchemy import func
+from sqlalchemy.dialects.postgresql import BOOLEAN, INTEGER
+from sqlalchemy.sql import Subquery, select
+
+
+def create_my_workspace_access_rights_subquery(user_id: int) -> Subquery:
+    return (
+        select(
+            workspaces_access_rights.c.workspace_id,
+            func.json_build_object(
+                "read",
+                func.max(workspaces_access_rights.c.read.cast(INTEGER)).cast(BOOLEAN),
+                "write",
+                func.max(workspaces_access_rights.c.write.cast(INTEGER)).cast(BOOLEAN),
+                "delete",
+                func.max(workspaces_access_rights.c.delete.cast(INTEGER)).cast(BOOLEAN),
+            ).label("my_access_rights"),
+        )
+        .select_from(
+            workspaces_access_rights.join(
+                user_to_groups, user_to_groups.c.gid == workspaces_access_rights.c.gid
+            )
+        )
+        .where(user_to_groups.c.uid == user_id)
+        .group_by(workspaces_access_rights.c.workspace_id)
+    ).subquery("my_workspace_access_rights_subquery")

packages/service-library/src/servicelib/redis.py

@@ -60,6 +60,7 @@ async def _cancel_or_warn(task: Task) -> None:
 @dataclass
 class RedisClientSDK:
     redis_dsn: str
+    client_name: str
     decode_responses: bool = _DEFAULT_DECODE_RESPONSES
     health_check_interval: datetime.timedelta = _DEFAULT_HEALTH_CHECK_INTERVAL
 
@@ -86,7 +87,7 @@ def __post_init__(self):
             socket_connect_timeout=_DEFAULT_SOCKET_TIMEOUT.total_seconds(),
             encoding="utf-8",
             decode_responses=self.decode_responses,
-            auto_close_connection_pool=True,
+            client_name=self.client_name,
         )
 
     @retry(**RedisRetryPolicyUponInitialization(_logger).kwargs)
@@ -238,6 +239,7 @@ class RedisClientsManager:
 
     databases_configs: set[RedisManagerDBConfig]
     settings: RedisSettings
+    client_name: str
 
     _client_sdks: dict[RedisDatabase, RedisClientSDK] = field(default_factory=dict)
 
@@ -247,6 +249,7 @@ async def setup(self) -> None:
                 redis_dsn=self.settings.build_redis_dsn(config.database),
                 decode_responses=config.decode_responses,
                 health_check_interval=config.health_check_interval,
+                client_name=f"{self.client_name}",
             )
 
         for client in self._client_sdks.values():

packages/service-library/tests/conftest.py

@@ -80,9 +80,12 @@ async def _(
         database: RedisDatabase, decode_response: bool = True  # noqa: FBT002
     ) -> AsyncIterator[RedisClientSDK]:
         redis_resources_dns = redis_service.build_redis_dsn(database)
-        client = RedisClientSDK(redis_resources_dns, decode_responses=decode_response)
+        client = RedisClientSDK(
+            redis_resources_dns, decode_responses=decode_response, client_name="pytest"
+        )
         assert client
         assert client.redis_dsn == redis_resources_dns
+        assert client.client_name == "pytest"
         await client.setup()
 
         yield client
@@ -94,7 +97,9 @@ async def _cleanup_redis_data(clients_manager: RedisClientsManager) -> None:
             await clients_manager.client(db).redis.flushall()
 
     async with RedisClientsManager(
-        {RedisManagerDBConfig(db) for db in RedisDatabase}, redis_service
+        {RedisManagerDBConfig(db) for db in RedisDatabase},
+        redis_service,
+        client_name="pytest",
     ) as clients_manager:
         await _cleanup_redis_data(clients_manager)
         yield _

packages/service-library/tests/deferred_tasks/example_app.py

@@ -60,6 +60,7 @@ def __init__(self, redis_settings: RedisSettings, port: int) -> None:
         self.redis: Redis = RedisClientSDK(
             redis_settings.build_redis_dsn(RedisDatabase.DEFERRED_TASKS),
             decode_responses=True,
+            client_name="example_app",
         ).redis
         self.port = port
 
@@ -84,6 +85,7 @@ def __init__(
         self._redis_client = RedisClientSDK(
             redis_settings.build_redis_dsn(RedisDatabase.DEFERRED_TASKS),
             decode_responses=False,
+            client_name="example_app",
         )
         self._manager = DeferredManager(
             rabbit_settings,

packages/service-library/tests/deferred_tasks/test__base_deferred_handler.py

@@ -55,6 +55,7 @@ async def redis_client_sdk(
     sdk = RedisClientSDK(
         redis_service.build_redis_dsn(RedisDatabase.DEFERRED_TASKS),
         decode_responses=False,
+        client_name="pytest",
     )
     await sdk.setup()
     yield sdk

packages/service-library/tests/test_pools.py

@@ -1,4 +1,4 @@
-from asyncio import BaseEventLoop
+import asyncio
 from concurrent.futures import ProcessPoolExecutor
 
 from servicelib.pools import (
@@ -11,17 +11,25 @@ def return_int_one() -> int:
     return 1
 
 
-async def test_default_thread_pool_executor(event_loop: BaseEventLoop) -> None:
-    assert await event_loop.run_in_executor(None, return_int_one) == 1
+async def test_default_thread_pool_executor() -> None:
+    assert await asyncio.get_running_loop().run_in_executor(None, return_int_one) == 1
 
 
-async def test_blocking_process_pool_executor(event_loop: BaseEventLoop) -> None:
-    assert await event_loop.run_in_executor(ProcessPoolExecutor(), return_int_one) == 1
+async def test_blocking_process_pool_executor() -> None:
+    assert (
+        await asyncio.get_running_loop().run_in_executor(
+            ProcessPoolExecutor(), return_int_one
+        )
+        == 1
+    )
 
 
-async def test_non_blocking_process_pool_executor(event_loop: BaseEventLoop) -> None:
+async def test_non_blocking_process_pool_executor() -> None:
     with non_blocking_process_pool_executor() as executor:
-        assert await event_loop.run_in_executor(executor, return_int_one) == 1
+        assert (
+            await asyncio.get_running_loop().run_in_executor(executor, return_int_one)
+            == 1
+        )
 
 
 async def test_same_pool_instances() -> None:
@@ -36,9 +44,12 @@ async def test_different_pool_instances() -> None:
         assert first != second
 
 
-async def test_non_blocking_thread_pool_executor(event_loop: BaseEventLoop) -> None:
+async def test_non_blocking_thread_pool_executor() -> None:
     with non_blocking_thread_pool_executor() as executor:
-        assert await event_loop.run_in_executor(executor, return_int_one) == 1
+        assert (
+            await asyncio.get_running_loop().run_in_executor(executor, return_int_one)
+            == 1
+        )
 
 
 async def test_same_thread_pool_instances() -> None:

packages/service-library/tests/test_redis.py

@@ -277,7 +277,9 @@ async def test_redis_client_sdks_manager(
         RedisManagerDBConfig(db) for db in RedisDatabase
     }
     manager = RedisClientsManager(
-        databases_configs=all_redis_configs, settings=redis_service
+        databases_configs=all_redis_configs,
+        settings=redis_service,
+        client_name="pytest",
     )
 
     async with manager:
@@ -290,7 +292,7 @@ async def test_redis_client_sdk_setup_shutdown(
 ):
     # setup
     redis_resources_dns = redis_service.build_redis_dsn(RedisDatabase.RESOURCES)
-    client = RedisClientSDK(redis_resources_dns)
+    client = RedisClientSDK(redis_resources_dns, client_name="pytest")
     assert client
     assert client.redis_dsn == redis_resources_dns