@hybridlabor-api/bdb-hardware-pcb 0.1.0

package/mcp_servers/openscad-mcp-server/legacy/test_remote_cuda_mvs.py

@@ -0,0 +1,283 @@
+"""
+Test script for remote CUDA Multi-View Stereo processing.
+"""
+
+import os
+import sys
+import logging
+import unittest
+from unittest.mock import patch, MagicMock
+from pathlib import Path
+
+# Add the src directory to the path
+sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+
+from src.remote.cuda_mvs_client import CUDAMVSClient
+from src.remote.connection_manager import CUDAMVSConnectionManager
+from src.config import REMOTE_CUDA_MVS
+
+# Configure logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+class TestRemoteCUDAMVS(unittest.TestCase):
+    """
+    Test cases for remote CUDA Multi-View Stereo processing.
+    """
+    
+    def setUp(self):
+        """
+        Set up test environment.
+        """
+        # Create test output directories
+        self.test_output_dir = "output/test_remote_cuda_mvs"
+        os.makedirs(self.test_output_dir, exist_ok=True)
+        
+        # Mock API key
+        self.api_key = "test_api_key"
+        
+        # Create the client with the mock API key
+        self.client = CUDAMVSClient(
+            api_key=self.api_key,
+            output_dir=self.test_output_dir
+        )
+        
+        # Create the connection manager with the mock API key
+        self.connection_manager = CUDAMVSConnectionManager(
+            api_key=self.api_key,
+            discovery_port=REMOTE_CUDA_MVS["DISCOVERY_PORT"],
+            use_lan_discovery=True
+        )
+    
+    @patch('src.remote.cuda_mvs_client.requests.post')
+    def test_upload_images(self, mock_post):
+        """
+        Test uploading images to a remote CUDA MVS server.
+        """
+        # Mock response
+        mock_response = MagicMock()
+        mock_response.status_code = 200
+        mock_response.json.return_value = {
+            "job_id": "test_job_123",
+            "status": "uploaded",
+            "message": "Images uploaded successfully"
+        }
+        mock_post.return_value = mock_response
+        
+        # Test parameters
+        server_url = "http://test-server:8765"
+        image_paths = [
+            os.path.join(self.test_output_dir, "test_image_1.png"),
+            os.path.join(self.test_output_dir, "test_image_2.png")
+        ]
+        
+        # Create test images
+        for path in image_paths:
+            with open(path, "w") as f:
+                f.write("test image data")
+        
+        # Call the method
+        result = self.client.upload_images(server_url, image_paths)
+        
+        # Verify the result
+        self.assertIsNotNone(result)
+        self.assertEqual(result["job_id"], "test_job_123")
+        self.assertEqual(result["status"], "uploaded")
+        
+        # Verify the API call
+        mock_post.assert_called_once()
+        args, kwargs = mock_post.call_args
+        self.assertTrue(server_url in args[0])
+        self.assertEqual(kwargs["headers"]["Authorization"], f"Bearer {self.api_key}")
+    
+    @patch('src.remote.cuda_mvs_client.requests.post')
+    def test_process_job(self, mock_post):
+        """
+        Test processing a job on a remote CUDA MVS server.
+        """
+        # Mock response
+        mock_response = MagicMock()
+        mock_response.status_code = 200
+        mock_response.json.return_value = {
+            "job_id": "test_job_123",
+            "status": "processing",
+            "message": "Job started processing"
+        }
+        mock_post.return_value = mock_response
+        
+        # Test parameters
+        server_url = "http://test-server:8765"
+        job_id = "test_job_123"
+        params = {
+            "quality": "normal",
+            "output_format": "obj"
+        }
+        
+        # Call the method
+        result = self.client.process_job(server_url, job_id, params)
+        
+        # Verify the result
+        self.assertIsNotNone(result)
+        self.assertEqual(result["job_id"], "test_job_123")
+        self.assertEqual(result["status"], "processing")
+        
+        # Verify the API call
+        mock_post.assert_called_once()
+        args, kwargs = mock_post.call_args
+        self.assertTrue(server_url in args[0])
+        self.assertEqual(kwargs["headers"]["Authorization"], f"Bearer {self.api_key}")
+        self.assertEqual(kwargs["json"]["job_id"], job_id)
+        self.assertEqual(kwargs["json"]["params"]["quality"], "normal")
+    
+    @patch('src.remote.cuda_mvs_client.requests.get')
+    def test_get_job_status(self, mock_get):
+        """
+        Test getting the status of a job on a remote CUDA MVS server.
+        """
+        # Mock response
+        mock_response = MagicMock()
+        mock_response.status_code = 200
+        mock_response.json.return_value = {
+            "job_id": "test_job_123",
+            "status": "completed",
+            "progress": 100,
+            "message": "Job completed successfully"
+        }
+        mock_get.return_value = mock_response
+        
+        # Test parameters
+        server_url = "http://test-server:8765"
+        job_id = "test_job_123"
+        
+        # Call the method
+        result = self.client.get_job_status(server_url, job_id)
+        
+        # Verify the result
+        self.assertIsNotNone(result)
+        self.assertEqual(result["job_id"], "test_job_123")
+        self.assertEqual(result["status"], "completed")
+        self.assertEqual(result["progress"], 100)
+        
+        # Verify the API call
+        mock_get.assert_called_once()
+        args, kwargs = mock_get.call_args
+        self.assertTrue(server_url in args[0])
+        self.assertEqual(kwargs["headers"]["Authorization"], f"Bearer {self.api_key}")
+    
+    @patch('src.remote.cuda_mvs_client.requests.get')
+    def test_download_model(self, mock_get):
+        """
+        Test downloading a model from a remote CUDA MVS server.
+        """
+        # Mock response
+        mock_response = MagicMock()
+        mock_response.status_code = 200
+        mock_response.content = b"test model data"
+        mock_get.return_value = mock_response
+        
+        # Test parameters
+        server_url = "http://test-server:8765"
+        job_id = "test_job_123"
+        output_dir = os.path.join(self.test_output_dir, "models")
+        os.makedirs(output_dir, exist_ok=True)
+        
+        # Call the method
+        result = self.client.download_model(server_url, job_id, output_dir)
+        
+        # Verify the result
+        self.assertIsNotNone(result)
+        self.assertTrue("model_path" in result)
+        self.assertTrue(os.path.exists(result["model_path"]))
+        
+        # Verify the API call
+        mock_get.assert_called()
+        args, kwargs = mock_get.call_args_list[0]
+        self.assertTrue(server_url in args[0])
+        self.assertEqual(kwargs["headers"]["Authorization"], f"Bearer {self.api_key}")
+    
+    @patch('src.remote.connection_manager.zeroconf.Zeroconf')
+    def test_discover_servers(self, mock_zeroconf):
+        """
+        Test discovering CUDA MVS servers on the network.
+        """
+        # Mock Zeroconf
+        mock_zeroconf_instance = MagicMock()
+        mock_zeroconf.return_value = mock_zeroconf_instance
+        
+        # Mock ServiceBrowser
+        with patch('src.remote.connection_manager.ServiceBrowser') as mock_browser:
+            # Set up the connection manager to discover servers
+            self.connection_manager.discover_servers()
+            
+            # Verify Zeroconf was initialized
+            mock_zeroconf.assert_called_once()
+            
+            # Verify ServiceBrowser was initialized
+            mock_browser.assert_called_once()
+            args, kwargs = mock_browser.call_args
+            self.assertEqual(args[0], mock_zeroconf_instance)
+            self.assertEqual(args[1], "_cudamvs._tcp.local.")
+    
+    @patch('src.remote.connection_manager.CUDAMVSClient')
+    def test_upload_images_with_connection_manager(self, mock_client_class):
+        """
+        Test uploading images using the connection manager.
+        """
+        # Mock client
+        mock_client = MagicMock()
+        mock_client_class.return_value = mock_client
+        
+        # Mock upload_images method
+        mock_client.upload_images.return_value = {
+            "job_id": "test_job_123",
+            "status": "uploaded",
+            "message": "Images uploaded successfully"
+        }
+        
+        # Add a mock server
+        self.connection_manager.servers = {
+            "test_server": {
+                "id": "test_server",
+                "name": "Test Server",
+                "url": "http://test-server:8765",
+                "status": "online"
+            }
+        }
+        
+        # Test parameters
+        server_id = "test_server"
+        image_paths = [
+            os.path.join(self.test_output_dir, "test_image_1.png"),
+            os.path.join(self.test_output_dir, "test_image_2.png")
+        ]
+        
+        # Create test images
+        for path in image_paths:
+            with open(path, "w") as f:
+                f.write("test image data")
+        
+        # Call the method
+        result = self.connection_manager.upload_images(server_id, image_paths)
+        
+        # Verify the result
+        self.assertIsNotNone(result)
+        self.assertEqual(result["job_id"], "test_job_123")
+        self.assertEqual(result["status"], "uploaded")
+        
+        # Verify the client method was called
+        mock_client.upload_images.assert_called_once()
+        args, kwargs = mock_client.upload_images.call_args
+        self.assertEqual(args[0], "http://test-server:8765")
+        self.assertEqual(args[1], image_paths)
+    
+    def tearDown(self):
+        """
+        Clean up after tests.
+        """
+        # Clean up test output directory
+        import shutil
+        if os.path.exists(self.test_output_dir):
+            shutil.rmtree(self.test_output_dir)
+
+if __name__ == "__main__":
+    unittest.main()

package/mcp_servers/openscad-mcp-server/legacy/test_venice_example.py

@@ -0,0 +1,69 @@
+import os
+import requests
+import json
+
+# Venice.ai API configuration
+VENICE_API_KEY = os.getenv("VENICE_API_KEY", "")  # Set via environment variable
+OUTPUT_DIR = os.path.join(os.path.dirname(os.path.abspath(__file__)), "output", "images")
+os.makedirs(OUTPUT_DIR, exist_ok=True)
+
+# API endpoint
+url = "https://api.venice.ai/api/v1/image/generate"
+
+# Test prompt
+prompt = "A coffee mug with geometric patterns"
+
+# Prepare payload
+payload = {
+    "model": "fluently-xl",  # Try default model instead of flux
+    "prompt": prompt,
+    "height": 1024,
+    "width": 1024,
+    "steps": 20,
+    "return_binary": False,
+    "hide_watermark": False,
+    "format": "png",
+    "embed_exif_metadata": False
+}
+
+# Set up headers
+headers = {
+    "Authorization": f"Bearer {VENICE_API_KEY}",
+    "Content-Type": "application/json"
+}
+
+print(f"Sending request to {url} with prompt: '{prompt}'")
+
+# Make API request
+try:
+    response = requests.post(url, json=payload, headers=headers)
+    
+    print(f"Response status: {response.status_code}")
+    
+    if response.status_code == 200:
+        result = response.json()
+        print("\nImage generation result:")
+        print(json.dumps(result, indent=2))
+        
+        # Print image URL if available
+        if "images" in result and len(result["images"]) > 0:
+            image_url = result["images"][0]
+            print(f"\nImage URL: {image_url}")
+            
+            # Download image
+            image_filename = f"{prompt[:20].replace(' ', '_')}_flux.png"
+            image_path = os.path.join(OUTPUT_DIR, image_filename)
+            
+            print(f"Downloading image to {image_path}...")
+            img_response = requests.get(image_url, stream=True)
+            if img_response.status_code == 200:
+                with open(image_path, 'wb') as f:
+                    for chunk in img_response.iter_content(chunk_size=8192):
+                        f.write(chunk)
+                print(f"Image saved to {image_path}")
+            else:
+                print(f"Failed to download image: {img_response.status_code}")
+    else:
+        print(f"Error: {response.text}")
+except Exception as e:
+    print(f"Error: {str(e)}")

package/mcp_servers/openscad-mcp-server/pyproject.toml

@@ -0,0 +1,33 @@
+[build-system]
+requires = ["hatchling>=1.27,<2"]
+build-backend = "hatchling.build"
+
+[project]
+name = "openscad-mcp-server"
+version = "0.2.0"
+description = "Local MCP tools for generating, rendering, and exporting OpenSCAD models"
+readme = "README.md"
+license = "MIT"
+license-files = ["LICENSE"]
+requires-python = ">=3.11"
+dependencies = ["mcp>=1.12,<2", "fastapi>=0.115,<1", "uvicorn>=0.30,<1"]
+
+[project.scripts]
+openscad-mcp = "openscad_mcp.server:main"
+
+[dependency-groups]
+dev = ["pytest>=8,<10", "pytest-asyncio>=1,<2", "trimesh>=4,<5", "pillow>=11,<13", "ruff>=0.12,<1"]
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/openscad_mcp"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+asyncio_mode = "auto"
+markers = ["integration: requires the real OpenSCAD executable"]
+
+[tool.ruff]
+include = ["src/openscad_mcp/**/*.py", "tests/**/*.py", "scripts/**/*.py"]
+
+[tool.ruff.lint]
+select = ["E4", "E7", "E9", "F", "I"]

package/mcp_servers/openscad-mcp-server/requirements.txt

@@ -0,0 +1,2 @@
+# Install the supported server. Development: uv sync --group dev
+.

package/mcp_servers/openscad-mcp-server/scad/simple_cube.scad

@@ -0,0 +1,2 @@
+// Simple cube without dependencies
+cube([20, 20, 20], center=true);

package/mcp_servers/openscad-mcp-server/scripts/test_docker.py

@@ -0,0 +1,220 @@
+"""Exercise the built image through real stdio MCP, without network or a GPU."""
+
+import argparse
+import asyncio
+import base64
+import hashlib
+import io
+import json
+import os
+import subprocess
+import tempfile
+import uuid
+import zipfile
+from contextlib import asynccontextmanager
+from pathlib import Path
+
+import trimesh
+from mcp import ClientSession, StdioServerParameters
+from mcp.client.stdio import stdio_client
+from PIL import Image
+
+
+def docker(*args, check=True):
+    return subprocess.run(
+        ["docker", *args], capture_output=True, text=True, check=check
+    )
+
+
+def data(result):
+    assert not result.isError, result
+    return result.structuredContent or json.loads(result.content[0].text)
+
+
+@asynccontextmanager
+async def session_for(image, volume):
+    name = f"openscad-test-{uuid.uuid4().hex}"
+    params = StdioServerParameters(
+        command="docker",
+        args=[
+            "run",
+            "--rm",
+            "-i",
+            "--name",
+            name,
+            "--network",
+            "none",
+            "-v",
+            f"{volume}:/data",
+            image,
+        ],
+        env=dict(os.environ),
+    )
+    try:
+        async with stdio_client(params) as (read, write):
+            async with ClientSession(read, write) as session:
+                await session.initialize()
+                assert docker("exec", name, "id", "-u").stdout.strip() == "10001"
+                yield session, name
+    finally:
+        docker("rm", "-f", name, check=False)
+
+
+async def check(image):
+    volume = f"openscad-test-{uuid.uuid4().hex}"
+    docker("volume", "create", volume)
+    try:
+        async with session_for(image, volume) as (session, name):
+            assert len((await session.list_tools()).tools) == 8
+            capabilities = data(await session.call_tool("get_capabilities", {}))
+            model = data(
+                await session.call_tool(
+                    "create_3d_model",
+                    {
+                        "model_type": "box",
+                        "parameters": {
+                            "width": 40,
+                            "depth": 30,
+                            "height": 20,
+                            "thickness": 2,
+                        },
+                    },
+                )
+            )
+            model_id = model["model_id"]
+            preview_hashes = []
+            for view in ("perspective", "front", "top", "right"):
+                result = await session.call_tool(
+                    "get_model_preview", {"model_id": model_id, "view": view}
+                )
+                assert not result.isError, result
+                block = next(block for block in result.content if block.type == "image")
+                png = base64.b64decode(block.data)
+                with Image.open(io.BytesIO(png)) as rendered:
+                    assert rendered.size == (800, 600)
+                    assert len(rendered.getcolors(800 * 600)) >= 2
+                preview_hashes.append(hashlib.sha256(png).hexdigest())
+            assert len(set(preview_hashes)) == 4
+            with tempfile.TemporaryDirectory() as temporary:
+                for format in ("stl", "scad", "csg", "3mf"):
+                    exported = data(
+                        await session.call_tool(
+                            "export_model", {"model_id": model_id, "format": format}
+                        )
+                    )
+                    local = Path(temporary) / f"model.{format}"
+                    docker("cp", f"{name}:{exported['model_file']}", str(local))
+                    assert local.stat().st_size > 0
+                    if format == "stl":
+                        mesh = trimesh.load_mesh(local)
+                        assert mesh.is_watertight
+                        assert mesh.extents.tolist() == [40, 30, 20]
+                        assert abs(mesh.volume - (40 * 30 * 20 - 36 * 26 * 18)) < 0.01
+                    elif format == "3mf":
+                        with zipfile.ZipFile(local) as archive:
+                            assert any(p.endswith(".model") for p in archive.namelist())
+                source = data(
+                    await session.call_tool("get_model_source", {"model_id": model_id})
+                )
+                assert "width = 40;" in source["scad_code"]
+                modified = data(
+                    await session.call_tool(
+                        "modify_3d_model",
+                        {
+                            "model_id": model_id,
+                            "parameters": {"height": 25},
+                            "expected_revision": source["revision"],
+                        },
+                    )
+                )
+                assert modified["parameters"]["height"] == 25
+                stale = await session.call_tool(
+                    "modify_3d_model",
+                    {
+                        "model_id": model_id,
+                        "parameters": {"height": 50},
+                        "expected_revision": source["revision"],
+                    },
+                )
+                assert stale.isError
+                failed = await session.call_tool(
+                    "modify_3d_model",
+                    {"model_id": model_id, "scad_code": "invalid SCAD !!!"},
+                )
+                assert failed.isError
+                assert (
+                    data(await session.call_tool("get_model", {"model_id": model_id}))[
+                        "revision"
+                    ]
+                    == modified["revision"]
+                )
+            custom = data(
+                await session.call_tool(
+                    "create_model_from_scad",
+                    {"scad_code": "// café\nsize=4; cube(size);"},
+                )
+            )
+            custom_source = data(
+                await session.call_tool(
+                    "get_model_source", {"model_id": custom["model_id"]}
+                )
+            )
+            assert custom_source["scad_code"] == "// café\nsize=4; cube(size);"
+            edited_custom = data(
+                await session.call_tool(
+                    "modify_3d_model",
+                    {
+                        "model_id": custom["model_id"],
+                        "scad_code": custom_source["scad_code"].replace(
+                            "size=4", "size=6"
+                        ),
+                        "expected_revision": custom_source["revision"],
+                    },
+                )
+            )
+            with tempfile.TemporaryDirectory() as temporary:
+                path = Path(temporary) / "custom.stl"
+                docker("cp", f"{name}:{edited_custom['model_file']}", str(path))
+                assert abs(trimesh.load_mesh(path).volume - 216) < 0.01
+        # A fresh container reuses the named volume and recovers the successful edit.
+        async with session_for(image, volume) as (session, name):
+            restored = data(
+                await session.call_tool("get_model", {"model_id": model_id})
+            )
+            assert restored["parameters"]["height"] == 25
+            assert restored["revision"] == modified["revision"]
+            preview = await session.call_tool(
+                "get_model_preview", {"model_id": model_id}
+            )
+            assert not preview.isError
+        print(
+            json.dumps(
+                {
+                    "image": image,
+                    "openscad": capabilities["openscad"],
+                    "result": "passed",
+                    "checks": [
+                        "nonroot",
+                        "network disabled",
+                        "MCP handshake and tools",
+                        "geometry and volume",
+                        "four PNG views",
+                        "four exports",
+                        "edit",
+                        "SCAD source round trip",
+                        "stale-edit rejection",
+                        "failed-edit rollback",
+                        "container restart persistence",
+                    ],
+                },
+                indent=2,
+            )
+        )
+    finally:
+        docker("volume", "rm", volume)
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--image", default="openscad-mcp:local")
+    asyncio.run(check(parser.parse_args().image))

package/mcp_servers/openscad-mcp-server/src/openscad_mcp/__init__.py

@@ -0,0 +1,3 @@
+"""Local OpenSCAD MCP server."""
+
+__version__ = "0.2.0"

package/mcp_servers/openscad-mcp-server/src/openscad_mcp/__main__.py

@@ -0,0 +1,3 @@
+from .server import main
+
+main()