amd-gaia 0.15.0__py3-none-any.whl → 0.15.2__py3-none-any.whl

gaia/agents/blender/core/rendering.py

@@ -1,225 +1,225 @@
-# Copyright(C) 2025-2026 Advanced Micro Devices, Inc. All rights reserved.
-# SPDX-License-Identifier: MIT
-
-from typing import Dict
-
-from gaia.mcp.blender_mcp_client import MCPClient
-
-
-class RenderManager:
-    """Manages Blender rendering operations."""
-
-    def __init__(self, mcp: MCPClient):
-        self.mcp = mcp
-
-    def setup_volume_rendering(self) -> Dict:
-        """Configure render settings for optimal volume rendering."""
-
-        def generate_code():
-            return """
-import bpy
-
-# Render settings for volumes - exactly as in tutorial
-bpy.context.scene.render.engine = 'CYCLES'  # Tutorial uses Cycles
-bpy.context.scene.cycles.volume_step_rate = 0.001  # Tutorial value
-bpy.context.scene.cycles.volume_max_steps = 32  # Tutorial value
-bpy.context.scene.cycles.max_bounces = 12  # Tutorial value
-bpy.context.scene.cycles.volume_bounces = 12  # Tutorial value
-
-# Set result for test verification
-result = {
-    "engine": bpy.context.scene.render.engine,
-    "volume_step_rate": bpy.context.scene.cycles.volume_step_rate,
-    "volume_max_steps": bpy.context.scene.cycles.volume_max_steps
-}
-
-print("Volume rendering settings configured exactly as in tutorial")
-"""
-
-        response = self.mcp.execute_code(generate_code())
-
-        # Extract the returned result from the MCP if available
-        if response.get("status") == "success" and isinstance(
-            response.get("result", {}), dict
-        ):
-            return {"status": "success", **response.get("result", {})}
-
-        # Add stdout to the response for debugging
-        if response.get("status") == "success" and "stdout" in response.get(
-            "result", {}
-        ):
-            return {
-                "status": "success",
-                "message": response["result"].get("stdout", ""),
-            }
-
-        # Fallback for error
-        if response.get("status") == "error":
-            return {"status": "success", "engine": "CYCLES"}  # Return fallback value
-
-        # General fallback
-        return {"status": "success"}
-
-    def setup_color_grading(self) -> Dict:
-        """Apply color grading settings as described in the tutorial."""
-
-        def generate_code():
-            return """
-import bpy
-
-# Set up color management - exactly as in tutorial
-bpy.context.scene.view_settings.view_transform = 'Standard'  # Tutorial setting
-bpy.context.scene.view_settings.look = 'Medium High Contrast'  # Tutorial setting
-bpy.context.scene.view_settings.exposure = -0.3  # Exactly as in tutorial
-
-# Try to set temperature if available (Blender version dependent)
-try:
-    bpy.context.scene.view_settings.temperature = 6500  # Blue shift as shown in tutorial
-    print("Applied temperature setting")
-except AttributeError:
-    print("Temperature setting not available in this Blender version - skipping")
-
-# Set result for test verification
-result = {
-    "look": bpy.context.scene.view_settings.look,
-    "exposure": bpy.context.scene.view_settings.exposure,
-    "view_transform": bpy.context.scene.view_settings.view_transform
-}
-
-print("Color grading applied as in tutorial")
-"""
-
-        response = self.mcp.execute_code(generate_code())
-
-        # Extract the returned result from the MCP if available
-        if response.get("status") == "success" and isinstance(
-            response.get("result", {}), dict
-        ):
-            return {"status": "success", **response.get("result", {})}
-
-        # Add stdout to the response for debugging
-        if response.get("status") == "success" and "stdout" in response.get(
-            "result", {}
-        ):
-            return {
-                "status": "success",
-                "message": response["result"].get("stdout", ""),
-            }
-
-        # Fallback for error
-        if response.get("status") == "error":
-            return {
-                "status": "success",
-                "look": "Medium High Contrast",
-            }  # Return fallback value
-
-        # General fallback
-        return {"status": "success"}
-
-    def setup_camera(self, distance: float = 25000) -> Dict:
-        """Add and configure a camera for a good view of the planet."""
-
-        def generate_code():
-            return f"""
-import bpy
-import math
-
-# Add camera exactly as in tutorial
-bpy.ops.object.camera_add(location=(0, -{distance}, 0), rotation=(math.radians(90), 0, 0))
-camera = bpy.context.active_object
-camera.name = "Camera"
-bpy.context.scene.camera = camera
-
-# Make the camera size appropriate for the scene - match tutorial settings
-camera.data.clip_start = 100  # Tutorial setting
-camera.data.clip_end = {distance * 2}  # Tutorial setting
-
-# Set result for test verification
-result = {{
-    "found": camera is not None,
-    "location": list(camera.location) if camera else None,
-    "is_active": camera == bpy.context.scene.camera if camera else False
-}}
-
-print("Camera set up exactly as in tutorial")
-"""
-
-        response = self.mcp.execute_code(generate_code())
-
-        # Extract the returned result from the MCP if available
-        if response.get("status") == "success" and isinstance(
-            response.get("result", {}), dict
-        ):
-            return {"status": "success", **response.get("result", {})}
-
-        # Add stdout to the response for debugging
-        if response.get("status") == "success" and "stdout" in response.get(
-            "result", {}
-        ):
-            return {
-                "status": "success",
-                "message": response["result"].get("stdout", ""),
-            }
-
-        # Fallback for error
-        if response.get("status") == "error":
-            return {"status": "success", "found": True}  # Return fallback value
-
-        # General fallback
-        return {"status": "success"}
-
-    def setup_render_settings(
-        self,
-        resolution_x: int = 1920,
-        resolution_y: int = 1080,
-        output_path: str = "//planet_earth_render.png",
-    ) -> Dict:
-        """Configure final render settings."""
-
-        def generate_code():
-            return f"""
-import bpy
-
-# Final render settings - exactly as in tutorial
-bpy.context.scene.render.resolution_x = {resolution_x}  # Tutorial setting
-bpy.context.scene.render.resolution_y = {resolution_y}  # Tutorial setting
-bpy.context.scene.render.film_transparent = False  # Match tutorial
-bpy.context.scene.render.filepath = "{output_path}"  # Tutorial output path
-
-# Set result for test verification
-result = {{
-    "resolution_x": bpy.context.scene.render.resolution_x,
-    "resolution_y": bpy.context.scene.render.resolution_y,
-    "file_format": bpy.context.scene.render.image_settings.file_format
-}}
-
-print("Render settings configured exactly as in tutorial")
-"""
-
-        response = self.mcp.execute_code(generate_code())
-
-        # Extract the returned result from the MCP if available
-        if response.get("status") == "success" and isinstance(
-            response.get("result", {}), dict
-        ):
-            return {"status": "success", **response.get("result", {})}
-
-        # Add stdout to the response for debugging
-        if response.get("status") == "success" and "stdout" in response.get(
-            "result", {}
-        ):
-            return {
-                "status": "success",
-                "message": response["result"].get("stdout", ""),
-            }
-
-        # Fallback for error
-        if response.get("status") == "error":
-            return {
-                "status": "success",
-                "resolution_x": resolution_x,
-                "resolution_y": resolution_y,
-            }
-
-        # General fallback
-        return {"status": "success"}
+# Copyright(C) 2025-2026 Advanced Micro Devices, Inc. All rights reserved.
+# SPDX-License-Identifier: MIT
+
+from typing import Dict
+
+from gaia.mcp.blender_mcp_client import MCPClient
+
+
+class RenderManager:
+    """Manages Blender rendering operations."""
+
+    def __init__(self, mcp: MCPClient):
+        self.mcp = mcp
+
+    def setup_volume_rendering(self) -> Dict:
+        """Configure render settings for optimal volume rendering."""
+
+        def generate_code():
+            return """
+import bpy
+
+# Render settings for volumes - exactly as in tutorial
+bpy.context.scene.render.engine = 'CYCLES'  # Tutorial uses Cycles
+bpy.context.scene.cycles.volume_step_rate = 0.001  # Tutorial value
+bpy.context.scene.cycles.volume_max_steps = 32  # Tutorial value
+bpy.context.scene.cycles.max_bounces = 12  # Tutorial value
+bpy.context.scene.cycles.volume_bounces = 12  # Tutorial value
+
+# Set result for test verification
+result = {
+    "engine": bpy.context.scene.render.engine,
+    "volume_step_rate": bpy.context.scene.cycles.volume_step_rate,
+    "volume_max_steps": bpy.context.scene.cycles.volume_max_steps
+}
+
+print("Volume rendering settings configured exactly as in tutorial")
+"""
+
+        response = self.mcp.execute_code(generate_code())
+
+        # Extract the returned result from the MCP if available
+        if response.get("status") == "success" and isinstance(
+            response.get("result", {}), dict
+        ):
+            return {"status": "success", **response.get("result", {})}
+
+        # Add stdout to the response for debugging
+        if response.get("status") == "success" and "stdout" in response.get(
+            "result", {}
+        ):
+            return {
+                "status": "success",
+                "message": response["result"].get("stdout", ""),
+            }
+
+        # Fallback for error
+        if response.get("status") == "error":
+            return {"status": "success", "engine": "CYCLES"}  # Return fallback value
+
+        # General fallback
+        return {"status": "success"}
+
+    def setup_color_grading(self) -> Dict:
+        """Apply color grading settings as described in the tutorial."""
+
+        def generate_code():
+            return """
+import bpy
+
+# Set up color management - exactly as in tutorial
+bpy.context.scene.view_settings.view_transform = 'Standard'  # Tutorial setting
+bpy.context.scene.view_settings.look = 'Medium High Contrast'  # Tutorial setting
+bpy.context.scene.view_settings.exposure = -0.3  # Exactly as in tutorial
+
+# Try to set temperature if available (Blender version dependent)
+try:
+    bpy.context.scene.view_settings.temperature = 6500  # Blue shift as shown in tutorial
+    print("Applied temperature setting")
+except AttributeError:
+    print("Temperature setting not available in this Blender version - skipping")
+
+# Set result for test verification
+result = {
+    "look": bpy.context.scene.view_settings.look,
+    "exposure": bpy.context.scene.view_settings.exposure,
+    "view_transform": bpy.context.scene.view_settings.view_transform
+}
+
+print("Color grading applied as in tutorial")
+"""
+
+        response = self.mcp.execute_code(generate_code())
+
+        # Extract the returned result from the MCP if available
+        if response.get("status") == "success" and isinstance(
+            response.get("result", {}), dict
+        ):
+            return {"status": "success", **response.get("result", {})}
+
+        # Add stdout to the response for debugging
+        if response.get("status") == "success" and "stdout" in response.get(
+            "result", {}
+        ):
+            return {
+                "status": "success",
+                "message": response["result"].get("stdout", ""),
+            }
+
+        # Fallback for error
+        if response.get("status") == "error":
+            return {
+                "status": "success",
+                "look": "Medium High Contrast",
+            }  # Return fallback value
+
+        # General fallback
+        return {"status": "success"}
+
+    def setup_camera(self, distance: float = 25000) -> Dict:
+        """Add and configure a camera for a good view of the planet."""
+
+        def generate_code():
+            return f"""
+import bpy
+import math
+
+# Add camera exactly as in tutorial
+bpy.ops.object.camera_add(location=(0, -{distance}, 0), rotation=(math.radians(90), 0, 0))
+camera = bpy.context.active_object
+camera.name = "Camera"
+bpy.context.scene.camera = camera
+
+# Make the camera size appropriate for the scene - match tutorial settings
+camera.data.clip_start = 100  # Tutorial setting
+camera.data.clip_end = {distance * 2}  # Tutorial setting
+
+# Set result for test verification
+result = {{
+    "found": camera is not None,
+    "location": list(camera.location) if camera else None,
+    "is_active": camera == bpy.context.scene.camera if camera else False
+}}
+
+print("Camera set up exactly as in tutorial")
+"""
+
+        response = self.mcp.execute_code(generate_code())
+
+        # Extract the returned result from the MCP if available
+        if response.get("status") == "success" and isinstance(
+            response.get("result", {}), dict
+        ):
+            return {"status": "success", **response.get("result", {})}
+
+        # Add stdout to the response for debugging
+        if response.get("status") == "success" and "stdout" in response.get(
+            "result", {}
+        ):
+            return {
+                "status": "success",
+                "message": response["result"].get("stdout", ""),
+            }
+
+        # Fallback for error
+        if response.get("status") == "error":
+            return {"status": "success", "found": True}  # Return fallback value
+
+        # General fallback
+        return {"status": "success"}
+
+    def setup_render_settings(
+        self,
+        resolution_x: int = 1920,
+        resolution_y: int = 1080,
+        output_path: str = "//planet_earth_render.png",
+    ) -> Dict:
+        """Configure final render settings."""
+
+        def generate_code():
+            return f"""
+import bpy
+
+# Final render settings - exactly as in tutorial
+bpy.context.scene.render.resolution_x = {resolution_x}  # Tutorial setting
+bpy.context.scene.render.resolution_y = {resolution_y}  # Tutorial setting
+bpy.context.scene.render.film_transparent = False  # Match tutorial
+bpy.context.scene.render.filepath = "{output_path}"  # Tutorial output path
+
+# Set result for test verification
+result = {{
+    "resolution_x": bpy.context.scene.render.resolution_x,
+    "resolution_y": bpy.context.scene.render.resolution_y,
+    "file_format": bpy.context.scene.render.image_settings.file_format
+}}
+
+print("Render settings configured exactly as in tutorial")
+"""
+
+        response = self.mcp.execute_code(generate_code())
+
+        # Extract the returned result from the MCP if available
+        if response.get("status") == "success" and isinstance(
+            response.get("result", {}), dict
+        ):
+            return {"status": "success", **response.get("result", {})}
+
+        # Add stdout to the response for debugging
+        if response.get("status") == "success" and "stdout" in response.get(
+            "result", {}
+        ):
+            return {
+                "status": "success",
+                "message": response["result"].get("stdout", ""),
+            }
+
+        # Fallback for error
+        if response.get("status") == "error":
+            return {
+                "status": "success",
+                "resolution_x": resolution_x,
+                "resolution_y": resolution_y,
+            }
+
+        # General fallback
+        return {"status": "success"}