cleanup

Author: pcrespov

services/web/server/src/simcore_service_webserver/groups/_classifiers_rest.py

@@ -51,7 +51,7 @@ async def get_scicrunch_resource(request: web.Request):
     rrid = request.match_info["rrid"]
 
     service = ScicrunchResourcesService(request.app)
-    resource = await service.get_or_fetch_resource(rrid)
+    resource = await service.get_or_fetch_reseach_resource(rrid)
 
     return envelope_json_response(resource.model_dump())
 
@@ -67,7 +67,7 @@ async def add_scicrunch_resource(request: web.Request):
     rrid = request.match_info["rrid"]
 
     service = ScicrunchResourcesService(request.app)
-    resource = await service.add_resource(rrid)
+    resource = await service.create_research_resource(rrid)
 
     return envelope_json_response(resource.model_dump())
 
@@ -83,6 +83,6 @@ async def search_scicrunch_resources(request: web.Request):
     guess_name = str(request.query["guess_name"]).strip()
 
     service = ScicrunchResourcesService(request.app)
-    hits: list[ResourceHit] = await service.search_resources(guess_name)
+    hits: list[ResourceHit] = await service.search_research_resources(guess_name)
 
     return envelope_json_response([hit.model_dump() for hit in hits])

services/web/server/src/simcore_service_webserver/groups/_classifiers_service.py

@@ -122,7 +122,7 @@ async def _build_rrids_tree_view(
         service = ScicrunchResourcesService(self.app)
 
         flat_tree_view: dict[TreePath, ClassifierItem] = {}
-        for resource in await service.list_resources():
+        for resource in await service.list_research_resources():
             try:
                 validated_item = ClassifierItem(
                     classifier=resource.rrid,

services/web/server/src/simcore_service_webserver/scicrunch/_service.py

@@ -16,14 +16,18 @@
 
 
 class ScicrunchResourcesService:
-    """Service layer handling business logic for scicrunch resources."""
+    """Service layer handling business logic for scicrunch resources.
+
+    - Research Resources operations (RRID = Research Resource ID)
+    """
 
     def __init__(self, app: web.Application):
         self.app = app
         self._repo = ScicrunchResourcesRepository.create_from_app(app)
-        self._scicrunch = SciCrunch.get_instance(self.app)
+        # client to interact with scicrunch.org service
+        self._client = SciCrunch.get_instance(self.app)
 
-    async def list_resources(self) -> list[ResearchResource]:
+    async def list_research_resources(self) -> list[ResearchResource]:
         """List all research resources as domain models."""
         rows = await self._repo.list_all_resources()
         if not rows:
@@ -47,85 +51,89 @@ async def list_resources(self) -> list[ResearchResource]:
 
         return resources
 
-    def get_resolver_web_url(self, rrid: str) -> HttpUrl:
-        """Get the resolver web URL for a given RRID."""
-        return self._scicrunch.get_resolver_web_url(rrid)
-
-    async def get_resource_atdb(self, rrid: str) -> ResearchResourceAtdB | None:
-        """Get resource with all database fields."""
-        row = await self._repo.get_resource_by_rrid(rrid)
-        if not row:
+    async def get_research_resource(self, rrid: str) -> ResearchResource | None:
+        """Get resource as domain model."""
+        resource_atdb = await self.get_resource_atdb(rrid)
+        if not resource_atdb:
             return None
 
         try:
-            return ResearchResourceAtdB.model_validate(dict(row))
+            return ResearchResource.model_validate(resource_atdb.model_dump())
         except ValidationError as err:
             _logger.exception(
                 **create_troubleshooting_log_kwargs(
-                    f"Invalid data for resource {rrid}",
+                    f"Failed to convert resource {rrid} to domain model",
                     error=err,
-                    error_context={"rrid": rrid, "row_data": dict(row)},
+                    error_context={
+                        "rrid": rrid,
+                        "resource_data": resource_atdb.model_dump(),
+                    },
                 )
             )
             return None
 
-    async def get_resource(self, rrid: str) -> ResearchResource | None:
-        """Get resource as domain model."""
-        resource_atdb = await self.get_resource_atdb(rrid)
-        if not resource_atdb:
+    async def get_or_fetch_reseach_resource(self, rrid: str) -> ResearchResource:
+        """Get resource from database first, fetch from SciCrunch API if not found."""
+        # Validate the RRID format first
+        validated_rrid = SciCrunch.validate_identifier(rrid)
+
+        # Check if in database first
+        resource = await self.get_research_resource(validated_rrid)
+        if resource:
+            return resource
+
+        # Otherwise, request from scicrunch service
+        return await self._client.get_resource_fields(validated_rrid)
+
+    async def get_resource_atdb(self, rrid: str) -> ResearchResourceAtdB | None:
+        """Get resource with all database fields."""
+        row = await self._repo.get_resource_by_rrid(rrid)
+        if not row:
             return None
 
         try:
-            return ResearchResource.model_validate(resource_atdb.model_dump())
+            return ResearchResourceAtdB.model_validate(dict(row))
         except ValidationError as err:
             _logger.exception(
                 **create_troubleshooting_log_kwargs(
-                    f"Failed to convert resource {rrid} to domain model",
+                    f"Invalid data for resource {rrid}",
                     error=err,
-                    error_context={
-                        "rrid": rrid,
-                        "resource_data": resource_atdb.model_dump(),
-                    },
+                    error_context={"rrid": rrid, "row_data": dict(row)},
                 )
             )
             return None
 
-    async def upsert_resource(self, resource: ResearchResource) -> ResearchResource:
-        """Create or update a research resource."""
-        values = resource.model_dump(exclude_unset=True)
-        row = await self._repo.upsert_resource(values)
-        return ResearchResource.model_validate(dict(row))
-
-    async def search_resources(self, guess_name: str) -> list[ResourceHit]:
+    async def search_research_resources(self, guess_name: str) -> list[ResourceHit]:
         """Search for research resources using SciCrunch API."""
         guess_name = guess_name.strip()
         if not guess_name:
             return []
 
-        return await self._scicrunch.search_resource(guess_name)
+        return await self._client.search_resource(guess_name)
 
-    async def add_resource(self, rrid: str) -> ResearchResource:
+    async def create_research_resource(self, rrid: str) -> ResearchResource:
         """Add a research resource by RRID, fetching from SciCrunch if not in database."""
         # Check if exists in database first
-        resource = await self.get_resource(rrid)
+        resource = await self.get_research_resource(rrid)
         if resource:
             return resource
 
         # If not found, request from scicrunch service
-        resource = await self._scicrunch.get_resource_fields(rrid)
+        resource = await self._client.get_resource_fields(rrid)
 
         # Insert new or update if exists
-        return await self.upsert_resource(resource)
+        return await self.upsert_research_resource(resource)
 
-    async def get_or_fetch_resource(self, rrid: str) -> ResearchResource:
-        """Get resource from database first, fetch from SciCrunch API if not found."""
-        # Validate the RRID format first
-        validated_rrid = SciCrunch.validate_identifier(rrid)
+    async def upsert_research_resource(
+        self, resource: ResearchResource
+    ) -> ResearchResource:
+        """Create or update a research resource."""
+        values = resource.model_dump(exclude_unset=True)
+        row = await self._repo.upsert_resource(values)
+        return ResearchResource.model_validate(dict(row))
 
-        # Check if in database first
-        resource = await self.get_resource(validated_rrid)
-        if resource:
-            return resource
+    # HELPERS --
 
-        # Otherwise, request from scicrunch service
-        return await self._scicrunch.get_resource_fields(validated_rrid)
+    def get_resolver_web_url(self, rrid: str) -> HttpUrl:
+        """Get the resolver web URL for a given RRID."""
+        return self._client.get_resolver_web_url(rrid)

services/web/server/tests/unit/with_dbs/01/test_groups_classifiers_repository.py

@@ -4,6 +4,7 @@
 # pylint: disable=too-many-arguments
 
 import pytest
+from models_library.groups import EVERYONE_GROUP_ID
 from pytest_simcore.helpers.faker_factories import random_group_classifier
 from pytest_simcore.helpers.postgres_tools import insert_and_get_row_lifespan
 from simcore_postgres_database.models.classifiers import group_classifiers
@@ -16,10 +17,10 @@
 @pytest.fixture
 async def group_classifier_in_db(asyncpg_engine: AsyncEngine):
     """Pre-populate group_classifiers table with test data."""
-    data = random_group_classifier(
-        gid=1,
-    )
+    data = random_group_classifier(gid=EVERYONE_GROUP_ID)
 
+    # pylint: disable=contextmanager-generator-missing-cleanup
+    # NOTE: this code is safe since `@asynccontextmanager` takes care of the cleanup
     async with insert_and_get_row_lifespan(
         asyncpg_engine,
         table=group_classifiers,