clean up

autogpt_platform/backend/backend/server/rest_api.py

@@ -45,7 +45,7 @@ def launch_darkly_context():
 
 
 @contextlib.asynccontextmanager
-async def lifespan_context(_lifespan_app: fastapi.FastAPI):
+async def lifespan_context(app: fastapi.FastAPI):
     await backend.data.db.connect()
     await backend.data.block.initialize_blocks()
     await backend.data.user.migrate_and_encrypt_user_integrations()

autogpt_platform/backend/backend/server/routers/v1.py

@@ -131,8 +131,8 @@ def execute_graph_block(block_id: str, data: BlockInput) -> CompletedBlockOutput
         raise HTTPException(status_code=404, detail=f"Block #{block_id} not found.")
 
     output = defaultdict(list)
-    for name, loop_data in obj.execute(data):
-        output[name].append(loop_data)
+    for name, data in obj.execute(data):
+        output[name].append(data)
     return output
 
 
@@ -380,25 +380,14 @@ async def update_graph(
     latest_version_number = max(g.version for g in existing_versions)
     graph.version = latest_version_number + 1
 
-    try:
-        latest_version_graph = next(
-            v for v in existing_versions if v.version == latest_version_number
-        )
-    except StopIteration:
-        raise HTTPException(404, detail=f"Graph #{graph_id} not found")
-
-    try:
-        current_active_version = next(
-            (v for v in existing_versions if v.is_active), None
-        )
-    except StopIteration:
-        raise HTTPException(404, detail=f"Graph #{graph_id} not found")
-
+    latest_version_graph = next(
+        v for v in existing_versions if v.version == latest_version_number
+    )
+    current_active_version = next((v for v in existing_versions if v.is_active), None)
     if latest_version_graph.is_template != graph.is_template:
         raise HTTPException(
             400, detail="Changing is_template on an existing graph is forbidden"
         )
-
     graph.is_active = not graph.is_template
     graph = graph_db.make_graph_model(graph, user_id)
     graph.reassign_ids(user_id=user_id)
@@ -411,11 +400,6 @@ async def update_graph(
             user_id, graph.id, graph.version
         )
 
-        # Keep the library agent up to date with the new active version
-        await backend.server.v2.library.db.update_agent_version_in_library(
-            user_id, graph.id, graph.version
-        )
-
         def get_credentials(credentials_id: str) -> "Credentials | None":
             return integration_creds_manager.get(user_id, credentials_id)
 
@@ -497,7 +481,6 @@ def execute_graph(
     graph_version: Optional[int] = None,
 ) -> ExecuteGraphResponse:
     try:
-        logger.info("Node input: %s", node_input)
         graph_exec = execution_manager_client().add_execution(
             graph_id, node_input, user_id=user_id, graph_version=graph_version
         )
@@ -647,7 +630,7 @@ async def create_api_key(
         )
         return CreateAPIKeyResponse(api_key=api_key, plain_text_key=plain_text)
     except APIKeyError as e:
-        logger.error("Failed to create API key: %s", e)
+        logger.error(f"Failed to create API key: {str(e)}")
         raise HTTPException(status_code=400, detail=str(e))
 
 
@@ -664,7 +647,7 @@ async def get_api_keys(
     try:
         return await list_user_api_keys(user_id)
     except APIKeyError as e:
-        logger.error("Failed to list API keys: %s", e)
+        logger.error(f"Failed to list API keys: {str(e)}")
         raise HTTPException(status_code=400, detail=str(e))
 
 
@@ -684,7 +667,7 @@ async def get_api_key(
             raise HTTPException(status_code=404, detail="API key not found")
         return api_key
     except APIKeyError as e:
-        logger.error("Failed to get API key: %s", e)
+        logger.error(f"Failed to get API key: {str(e)}")
         raise HTTPException(status_code=400, detail=str(e))
 
 
@@ -706,7 +689,7 @@ async def delete_api_key(
     except APIKeyPermissionError:
         raise HTTPException(status_code=403, detail="Permission denied")
     except APIKeyError as e:
-        logger.error("Failed to revoke API key: %s", e)
+        logger.error(f"Failed to revoke API key: {str(e)}")
         raise HTTPException(status_code=400, detail=str(e))
 
 
@@ -728,7 +711,7 @@ async def suspend_key(
     except APIKeyPermissionError:
         raise HTTPException(status_code=403, detail="Permission denied")
     except APIKeyError as e:
-        logger.error("Failed to suspend API key: %s", e)
+        logger.error(f"Failed to suspend API key: {str(e)}")
         raise HTTPException(status_code=400, detail=str(e))
 
 
@@ -752,5 +735,5 @@ async def update_permissions(
     except APIKeyPermissionError:
         raise HTTPException(status_code=403, detail="Permission denied")
     except APIKeyError as e:
-        logger.error("Failed to update API key permissions: %s", e)
+        logger.error(f"Failed to update API key permissions: {str(e)}")
         raise HTTPException(status_code=400, detail=str(e))

autogpt_platform/backend/backend/server/v2/library/db.py

@@ -9,8 +9,8 @@ import prisma.types
 import backend.server.model
 import backend.server.v2.library.model as library_model
 import backend.server.v2.store.exceptions as store_exceptions
-import backend.server.v2.store.image_gen
-import backend.server.v2.store.media
+import backend.server.v2.store.image_gen as store_image_gen
+import backend.server.v2.store.media as store_media
 
 logger = logging.getLogger(__name__)
 
@@ -89,15 +89,11 @@ async def create_library_agent(
             # Use .jpeg here since we are generating JPEG images
             filename = f"agent_{agent_id}.jpeg"
 
-            image_url = await backend.server.v2.store.media.check_media_exists(
-                user_id, filename
-            )
+            image_url = await store_media.check_media_exists(user_id, filename)
 
             if not image_url:
                 # Generate agent image as JPEG
-                image = await backend.server.v2.store.image_gen.generate_agent_image(
-                    agent=agent
-                )
+                image = await store_image_gen.generate_agent_image(agent=agent)
 
                 # Create UploadFile with the correct filename and content_type
                 image_file = fastapi.UploadFile(
@@ -105,11 +101,11 @@ async def create_library_agent(
                     filename=filename,
                 )
 
-                image_url = await backend.server.v2.store.media.upload_media(
+                image_url = await store_media.upload_media(
                     user_id=user_id, file=image_file, use_file_name=True
                 )
         except Exception as e:
-            logger.error("Error generating agent image: %s", e)
+            logger.error(f"Error generating agent image: {e}")
             raise store_exceptions.DatabaseError(
                 "Failed to generate agent image"
             ) from e
@@ -207,9 +203,8 @@ async def add_store_agent_to_library(
     if they don't already have it
     """
     logger.debug(
-        "Adding agent from store listing version %s to library for user %s",
-        store_listing_version_id,
-        user_id,
+        f"Adding agent from store listing version #{store_listing_version_id} "
+        f"to library for user #{user_id}"
     )
 
     try:
@@ -222,7 +217,7 @@ async def add_store_agent_to_library(
 
         if not store_listing_version or not store_listing_version.Agent:
             logger.warning(
-                "Store listing version not found: %s", store_listing_version_id
+                f"Store listing version not found: {store_listing_version_id}"
             )
             raise store_exceptions.AgentNotFoundError(
                 f"Store listing version {store_listing_version_id} not found"
@@ -234,7 +229,7 @@ async def add_store_agent_to_library(
 
         if agent.userId == user_id:
             logger.warning(
-                "User %s cannot add their own agent to their library", user_id
+                f"User #{user_id} cannot add their own agent to their library"
             )
             raise store_exceptions.DatabaseError("Cannot add own agent to library")
 
@@ -249,7 +244,7 @@ async def add_store_agent_to_library(
 
         if existing_user_agent:
             logger.debug(
-                "User %s already has agent %s in their library", user_id, agent.id
+                f"User #{user_id} already has agent #{agent.id} in their library"
             )
             return
 
@@ -262,7 +257,7 @@ async def add_store_agent_to_library(
                 "isCreatedByUser": False,
             }
         )
-        logger.debug("Added agent %s to library for user %s", agent.id, user_id)
+        logger.debug(f"Added agent #{agent.id} to library for user #{user_id}")
 
     except store_exceptions.AgentNotFoundError:
         raise

autogpt_platform/backend/backend/server/v2/store/db.py

@@ -766,21 +766,21 @@ async def get_agent(
             )
         )
 
-        if not store_listing_version:
+        if not store_listing_version or not store_listing_version.Agent:
             raise fastapi.HTTPException(
                 status_code=404,
                 detail=f"Store listing version {store_listing_version_id} not found",
             )
 
-        graph = await backend.data.graph.get_graph(
-            store_listing_version.agentId, store_listing_version.agentVersion
-        )
+        graph_id = store_listing_version.agentId
+        graph_version = store_listing_version.agentVersion
+        graph = await backend.data.graph.get_graph(graph_id, graph_version)
 
         if not graph:
             raise fastapi.HTTPException(
                 status_code=404,
                 detail=(
-                    f"Agent #{store_listing_version.agentId} not found "
+                    f"Agent #{graph_id} not found "
                     f"for store listing version #{store_listing_version_id}"
                 ),
             )