remove aiopg

Author: sanderegg

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

@@ -182,25 +182,5 @@ async def get_aggregated_properties_for_user(
         assert isinstance(rows, list)  # nosec
 
         return GroupExtraPropertiesRepo._aggregate(
-            rows, user_id, product_name, GroupExtraProperties.from_row_proxy
+            rows, user_id, product_name, GroupExtraProperties.from_row
         )
-
-    @staticmethod
-    async def get_aggregated_properties_for_user_v2(
-        engine: AsyncEngine,
-        connection: AsyncConnection | None = None,
-        *,
-        user_id: int,
-        product_name: str,
-    ) -> GroupExtraProperties:
-        async with pass_or_acquire_connection(engine, connection) as conn:
-            list_stmt = _list_table_entries_ordered_by_group_type_stmt(
-                user_id=user_id, product_name=product_name
-            )
-            result = await conn.stream(
-                sa.select(list_stmt).order_by(list_stmt.c.type_order)
-            )
-            rows = [row async for row in result]
-            return GroupExtraPropertiesRepo._aggregate(
-                rows, user_id, product_name, GroupExtraProperties.from_row
-            )

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

@@ -1,23 +1,30 @@
+from collections.abc import Mapping
 from dataclasses import fields, is_dataclass
-from typing import TypeVar
+from typing import Any, TypeVar
 
-from aiopg.sa.result import RowProxy
 from sqlalchemy.engine.row import Row
 
 ModelType = TypeVar("ModelType")
 
 
 class FromRowMixin:
-    """Mixin to allow instance construction from aiopg.sa.result.RowProxy"""
+    """Mixin to allow instance construction from database row objects"""
 
     @classmethod
-    def from_row_proxy(cls: type[ModelType], row: RowProxy) -> ModelType:
-        assert is_dataclass(cls)  # nosec
-        field_names = [f.name for f in fields(cls)]
-        return cls(**{k: v for k, v in row.items() if k in field_names})  # type: ignore[return-value]
+    def from_row(cls: type[ModelType], row: Any) -> ModelType:
+        """Creates an instance from a database row.
 
-    @classmethod
-    def from_row(cls: type[ModelType], row: Row) -> ModelType:
+        Supports both Row objects and mapping-like objects.
+        """
         assert is_dataclass(cls)  # nosec
+
+        if isinstance(row, Row):
+            mapping = row._asdict()
+        elif isinstance(row, Mapping):
+            mapping = row
+        else:
+            msg = f"Row must be a Row or Mapping type, got {type(row)}"
+            raise TypeError(msg)
+
         field_names = [f.name for f in fields(cls)]
-        return cls(**{k: v for k, v in row._asdict().items() if k in field_names})  # type: ignore[return-value]
+        return cls(**{k: v for k, v in mapping.items() if k in field_names})  # type: ignore[return-value]

packages/postgres-database/tests/test_utils_groups_extra_properties.py

@@ -69,7 +69,7 @@ async def _creator(
         assert result
         row = await result.first()
         assert row
-        properties = GroupExtraProperties.from_row_proxy(row)
+        properties = GroupExtraProperties.from_row(row)
         created_properties.append((properties.group_id, properties.product_name))
         return properties
 
@@ -365,115 +365,3 @@ async def test_get_aggregated_properties_for_user_returns_property_values_as_tru
     assert aggregated_group_properties.internet_access is False
     assert aggregated_group_properties.override_services_specifications is False
     assert aggregated_group_properties.use_on_demand_clusters is True
-
-
-async def test_get_aggregated_properties_for_user_returns_property_values_as_truthy_if_one_of_them_is_v2(
-    asyncpg_engine: AsyncEngine,
-    connection: aiopg.sa.connection.SAConnection,
-    connection_factory: aiopg.sa.connection.SAConnection | AsyncConnection,
-    product_name: str,
-    registered_user: RowProxy,
-    create_fake_product: Callable[[str], Awaitable[Row]],
-    create_fake_group: Callable[..., Awaitable[RowProxy]],
-    create_fake_group_extra_properties: Callable[..., Awaitable[GroupExtraProperties]],
-    everyone_group_id: int,
-):
-    await create_fake_product(product_name)
-    await create_fake_product(f"{product_name}_additional_just_for_fun")
-
-    # create a specific extra properties for group that disallow everything
-    everyone_group_extra_properties = await create_fake_group_extra_properties(
-        everyone_group_id,
-        product_name,
-        internet_access=False,
-        override_services_specifications=False,
-        use_on_demand_clusters=False,
-    )
-    # this should return the everyone group properties
-    aggregated_group_properties = (
-        await GroupExtraPropertiesRepo.get_aggregated_properties_for_user_v2(
-            asyncpg_engine, user_id=registered_user.id, product_name=product_name
-        )
-    )
-    assert aggregated_group_properties == everyone_group_extra_properties
-
-    # now we create some standard groups and add the user to them and make everything false for now
-    standard_groups = [await create_fake_group(connection) for _ in range(5)]
-    for group in standard_groups:
-        await create_fake_group_extra_properties(
-            group.gid,
-            product_name,
-            internet_access=False,
-            override_services_specifications=False,
-            use_on_demand_clusters=False,
-        )
-        await _add_user_to_group(
-            connection_factory, user_id=registered_user.id, group_id=group.gid
-        )
-
-    # now we still should not have any of these value Truthy
-    aggregated_group_properties = (
-        await GroupExtraPropertiesRepo.get_aggregated_properties_for_user_v2(
-            asyncpg_engine, user_id=registered_user.id, product_name=product_name
-        )
-    )
-    assert aggregated_group_properties.internet_access is False
-    assert aggregated_group_properties.override_services_specifications is False
-    assert aggregated_group_properties.use_on_demand_clusters is False
-
-    # let's change one of these standard groups
-    random_standard_group = random.choice(standard_groups)  # noqa: S311
-    result = await connection.execute(
-        groups_extra_properties.update()
-        .where(groups_extra_properties.c.group_id == random_standard_group.gid)
-        .values(internet_access=True)
-    )
-    assert result.rowcount == 1
-
-    # now we should have internet access
-    aggregated_group_properties = (
-        await GroupExtraPropertiesRepo.get_aggregated_properties_for_user_v2(
-            asyncpg_engine, user_id=registered_user.id, product_name=product_name
-        )
-    )
-    assert aggregated_group_properties.internet_access is True
-    assert aggregated_group_properties.override_services_specifications is False
-    assert aggregated_group_properties.use_on_demand_clusters is False
-
-    # let's change another one of these standard groups
-    random_standard_group = random.choice(standard_groups)  # noqa: S311
-    result = await connection.execute(
-        groups_extra_properties.update()
-        .where(groups_extra_properties.c.group_id == random_standard_group.gid)
-        .values(override_services_specifications=True)
-    )
-    assert result.rowcount == 1
-
-    # now we should have internet access and service override
-    aggregated_group_properties = (
-        await GroupExtraPropertiesRepo.get_aggregated_properties_for_user_v2(
-            asyncpg_engine, user_id=registered_user.id, product_name=product_name
-        )
-    )
-    assert aggregated_group_properties.internet_access is True
-    assert aggregated_group_properties.override_services_specifications is True
-    assert aggregated_group_properties.use_on_demand_clusters is False
-
-    # and we can deny it again by setting a primary extra property
-    # now create some personal extra properties
-    personal_group_extra_properties = await create_fake_group_extra_properties(
-        registered_user.primary_gid,
-        product_name,
-        internet_access=False,
-        use_on_demand_clusters=True,
-    )
-    assert personal_group_extra_properties
-
-    aggregated_group_properties = (
-        await GroupExtraPropertiesRepo.get_aggregated_properties_for_user_v2(
-            asyncpg_engine, user_id=registered_user.id, product_name=product_name
-        )
-    )
-    assert aggregated_group_properties.internet_access is False
-    assert aggregated_group_properties.override_services_specifications is False
-    assert aggregated_group_properties.use_on_demand_clusters is True

services/web/server/src/simcore_service_webserver/users/_users_repository.py

@@ -96,7 +96,6 @@ async def search_public_user(
     search_pattern: str,
     limit: int,
 ) -> list:
-
     _pattern = f"%{search_pattern}%"
 
     query = (
@@ -267,8 +266,8 @@ async def list_user_permissions(
     with contextlib.suppress(GroupExtraPropertiesNotFoundError):
         async with pass_or_acquire_connection(engine, connection) as conn:
             user_group_extra_properties = (
-                await GroupExtraPropertiesRepo.get_aggregated_properties_for_user_v2(
-                    engine, conn, user_id=user_id, product_name=product_name
+                await GroupExtraPropertiesRepo.get_aggregated_properties_for_user(
+                    conn, user_id=user_id, product_name=product_name
                 )
             )
         override_services_specifications.allowed = (
@@ -321,7 +320,6 @@ async def search_users_and_get_profile(
     *,
     email_like: str,
 ) -> list[Row]:
-
     users_alias = sa.alias(users, name="users_alias")
 
     invited_by = (
@@ -549,7 +547,6 @@ async def update_user_profile(
 
     if updated_values := update.to_db():
         try:
-
             async with transaction_context(engine=get_asyncpg_engine(app)) as conn:
                 await conn.execute(
                     users.update()