@hybridlabor-api/bdb-hardware-pcb 0.1.0

package/mcp_servers/openscad-mcp-server/legacy/src/testing/test_primitives.py

@@ -0,0 +1,98 @@
+import os
+import argparse
+import logging
+import json
+from typing import Dict, Any, List
+
+from src.models.code_generator import OpenSCADCodeGenerator
+from src.utils.cad_exporter import CADExporter
+from src.utils.format_validator import FormatValidator
+from src.testing.primitive_tester import PrimitiveTester
+
+# Configure logging
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
+)
+logger = logging.getLogger(__name__)
+
+def main():
+    parser = argparse.ArgumentParser(description='Test OpenSCAD primitives with different export formats')
+    parser.add_argument('--output-dir', default='test_output', help='Directory to store test output')
+    parser.add_argument('--formats', nargs='+', default=['3mf', 'amf', 'csg', 'scad'], 
+                       help='Formats to test (default: 3mf amf csg scad)')
+    parser.add_argument('--primitives', nargs='+', 
+                       help='Primitives to test (default: all)')
+    parser.add_argument('--validate', action='store_true', 
+                       help='Validate exported files')
+    parser.add_argument('--printer-type', choices=['prusa', 'bambu'], default='prusa',
+                       help='Printer type to check compatibility with (default: prusa)')
+    
+    args = parser.parse_args()
+    
+    # Create directories
+    os.makedirs("scad", exist_ok=True)
+    os.makedirs(args.output_dir, exist_ok=True)
+    
+    # Initialize components
+    # Use absolute path for templates to avoid path issues
+    templates_dir = os.path.abspath(os.path.join(os.path.dirname(__file__), "../../models/scad_templates"))
+    code_generator = OpenSCADCodeGenerator(templates_dir, "scad")
+    cad_exporter = CADExporter()
+    
+    # Initialize tester
+    tester = PrimitiveTester(code_generator, cad_exporter, args.output_dir)
+    
+    # Override formats if specified
+    if args.formats:
+        tester.formats = args.formats
+    
+    # Test primitives
+    if args.primitives:
+        results = {}
+        for primitive in args.primitives:
+            results[primitive] = tester.test_primitive(primitive)
+    else:
+        results = tester.test_all_primitives()
+    
+    # Print results
+    logger.info(f"Test results: {json.dumps(results, indent=2)}")
+    
+    # Validate exported files if requested
+    if args.validate:
+        validator = FormatValidator()
+        validation_results = {}
+        
+        for primitive, primitive_results in results.items():
+            validation_results[primitive] = {}
+            
+            for format_type, format_results in primitive_results["formats"].items():
+                if format_results["success"] and format_type in ['3mf', 'amf']:
+                    output_file = format_results["output_file"]
+                    
+                    if format_type == '3mf':
+                        is_valid, error = validator.validate_3mf(output_file)
+                    elif format_type == 'amf':
+                        is_valid, error = validator.validate_amf(output_file)
+                    else:
+                        is_valid, error = False, "Validation not supported for this format"
+                    
+                    # Check printer compatibility
+                    is_compatible, compat_error = validator.check_printer_compatibility(
+                        output_file, args.printer_type
+                    )
+                    
+                    metadata = validator.extract_metadata(output_file)
+                    
+                    validation_results[primitive][format_type] = {
+                        "is_valid": is_valid,
+                        "error": error,
+                        "is_compatible_with_printer": is_compatible,
+                        "compatibility_error": compat_error,
+                        "metadata": metadata
+                    }
+        
+        logger.info(f"Validation results: {json.dumps(validation_results, indent=2)}")
+
+if __name__ == "__main__":
+    main()

package/mcp_servers/openscad-mcp-server/legacy/src/utils/__init__.py

@@ -0,0 +1 @@
+# Utils package

package/mcp_servers/openscad-mcp-server/legacy/src/utils/cad_exporter.py

@@ -0,0 +1,241 @@
+import os
+import logging
+import subprocess
+from typing import Dict, Any, Optional, Tuple, List
+
+logger = logging.getLogger(__name__)
+
+class CADExporter:
+    """
+    Exports OpenSCAD models to various CAD formats that preserve parametric properties.
+    """
+    
+    def __init__(self, openscad_path: str = "openscad"):
+        """
+        Initialize the CAD exporter.
+        
+        Args:
+            openscad_path: Path to the OpenSCAD executable
+        """
+        self.openscad_path = openscad_path
+        
+        # Supported export formats
+        self.supported_formats = {
+            "csg": "OpenSCAD CSG format (preserves all parametric properties)",
+            "amf": "Additive Manufacturing File Format (preserves some metadata)",
+            "3mf": "3D Manufacturing Format (modern replacement for STL with metadata)",
+            "scad": "OpenSCAD source code (fully parametric)",
+            "dxf": "Drawing Exchange Format (for 2D designs)",
+            "svg": "Scalable Vector Graphics (for 2D designs)"
+        }
+    
+    def export_model(self, scad_file: str, output_format: str = "csg", 
+                    parameters: Optional[Dict[str, Any]] = None,
+                    metadata: Optional[Dict[str, Any]] = None) -> Tuple[bool, str, Optional[str]]:
+        """
+        Export an OpenSCAD model to the specified format.
+        
+        Args:
+            scad_file: Path to the SCAD file
+            output_format: Format to export to (csg, amf, 3mf, etc.)
+            parameters: Optional parameters to override in the SCAD file
+            metadata: Optional metadata to include in the export
+            
+        Returns:
+            Tuple of (success, output_file_path, error_message)
+        """
+        if not os.path.exists(scad_file):
+            return False, "", f"SCAD file not found: {scad_file}"
+        
+        # Create output file path
+        output_dir = os.path.dirname(scad_file)
+        model_id = os.path.basename(scad_file).split('.')[0]
+        
+        # Special case for SCAD format - just copy the file with parameters embedded
+        if output_format.lower() == "scad" and parameters:
+            return self._export_parametric_scad(scad_file, parameters, metadata)
+        
+        # For native OpenSCAD formats
+        output_file = os.path.join(output_dir, f"{model_id}.{output_format.lower()}")
+        
+        # Build command
+        cmd = [self.openscad_path, "-o", output_file]
+        
+        # Add parameters if provided
+        if parameters:
+            for key, value in parameters.items():
+                cmd.extend(["-D", f"{key}={value}"])
+        
+        # Add input file
+        cmd.append(scad_file)
+        
+        try:
+            # Run OpenSCAD
+            result = subprocess.run(cmd, check=True, capture_output=True, text=True)
+            
+            # Check if file was created
+            if os.path.exists(output_file) and os.path.getsize(output_file) > 0:
+                logger.info(f"Exported model to {output_format}: {output_file}")
+                
+                # Add metadata if supported and provided
+                if metadata and output_format.lower() in ["amf", "3mf"]:
+                    self._add_metadata_to_file(output_file, metadata, output_format)
+                
+                return True, output_file, None
+            else:
+                error_msg = f"Failed to export model to {output_format}"
+                logger.error(error_msg)
+                logger.error(f"OpenSCAD output: {result.stdout}")
+                logger.error(f"OpenSCAD error: {result.stderr}")
+                return False, "", error_msg
+        except subprocess.CalledProcessError as e:
+            error_msg = f"Error exporting model to {output_format}: {e.stderr}"
+            logger.error(error_msg)
+            return False, "", error_msg
+        except Exception as e:
+            error_msg = f"Error exporting model to {output_format}: {str(e)}"
+            logger.error(error_msg)
+            return False, "", error_msg
+    
+    def _export_parametric_scad(self, scad_file: str, parameters: Dict[str, Any],
+                               metadata: Optional[Dict[str, Any]] = None) -> Tuple[bool, str, Optional[str]]:
+        """
+        Create a new SCAD file with parameters embedded as variables.
+        
+        Args:
+            scad_file: Path to the original SCAD file
+            parameters: Parameters to embed in the SCAD file
+            metadata: Optional metadata to include as comments
+            
+        Returns:
+            Tuple of (success, output_file_path, error_message)
+        """
+        try:
+            # Read the original SCAD file
+            with open(scad_file, 'r') as f:
+                content = f.read()
+            
+            # Create output file path
+            output_dir = os.path.dirname(scad_file)
+            model_id = os.path.basename(scad_file).split('.')[0]
+            output_file = os.path.join(output_dir, f"{model_id}_parametric.scad")
+            
+            # Create parameter declarations
+            param_declarations = []
+            for key, value in parameters.items():
+                if isinstance(value, str):
+                    param_declarations.append(f'{key} = "{value}";')
+                else:
+                    param_declarations.append(f'{key} = {value};')
+            
+            # Create metadata comments
+            metadata_comments = []
+            if metadata:
+                metadata_comments.append("// Metadata:")
+                for key, value in metadata.items():
+                    metadata_comments.append(f"// {key}: {value}")
+            
+            # Combine everything
+            new_content = "// Parametric model generated by OpenSCAD MCP Server\n"
+            new_content += "\n".join(metadata_comments) + "\n\n" if metadata_comments else "\n"
+            new_content += "// Parameters:\n"
+            new_content += "\n".join(param_declarations) + "\n\n"
+            new_content += content
+            
+            # Write to the new file
+            with open(output_file, 'w') as f:
+                f.write(new_content)
+            
+            logger.info(f"Exported parametric SCAD file: {output_file}")
+            return True, output_file, None
+        except Exception as e:
+            error_msg = f"Error creating parametric SCAD file: {str(e)}"
+            logger.error(error_msg)
+            return False, "", error_msg
+    
+    def _add_metadata_to_file(self, file_path: str, metadata: Dict[str, Any], format_type: str) -> None:
+        """
+        Add metadata to supported file formats.
+        
+        Args:
+            file_path: Path to the file
+            metadata: Metadata to add
+            format_type: File format
+        """
+        if format_type.lower() == "amf":
+            self._add_metadata_to_amf(file_path, metadata)
+        elif format_type.lower() == "3mf":
+            self._add_metadata_to_3mf(file_path, metadata)
+    
+    def _add_metadata_to_amf(self, file_path: str, metadata: Dict[str, Any]) -> None:
+        """Add metadata to AMF file."""
+        try:
+            import xml.etree.ElementTree as ET
+            
+            # Parse the AMF file
+            tree = ET.parse(file_path)
+            root = tree.getroot()
+            
+            # Find or create metadata element
+            metadata_elem = root.find("metadata")
+            if metadata_elem is None:
+                metadata_elem = ET.SubElement(root, "metadata")
+            
+            # Add metadata
+            for key, value in metadata.items():
+                meta = ET.SubElement(metadata_elem, "meta", name=key)
+                meta.text = str(value)
+            
+            # Write back to file
+            tree.write(file_path)
+            logger.info(f"Added metadata to AMF file: {file_path}")
+        except Exception as e:
+            logger.error(f"Error adding metadata to AMF file: {str(e)}")
+    
+    def _add_metadata_to_3mf(self, file_path: str, metadata: Dict[str, Any]) -> None:
+        """Add metadata to 3MF file."""
+        try:
+            import zipfile
+            import xml.etree.ElementTree as ET
+            
+            # 3MF files are ZIP archives
+            with zipfile.ZipFile(file_path, 'a') as z:
+                # Check if metadata file exists
+                metadata_path = "Metadata/model_metadata.xml"
+                try:
+                    z.getinfo(metadata_path)
+                    # Extract existing metadata
+                    with z.open(metadata_path) as f:
+                        tree = ET.parse(f)
+                        root = tree.getroot()
+                except KeyError:
+                    # Create new metadata file
+                    root = ET.Element("metadata")
+                    tree = ET.ElementTree(root)
+                
+                # Add metadata
+                for key, value in metadata.items():
+                    meta = ET.SubElement(root, "meta", name=key)
+                    meta.text = str(value)
+                
+                # Write metadata to a temporary file
+                temp_path = file_path + ".metadata.tmp"
+                tree.write(temp_path)
+                
+                # Add to ZIP
+                z.write(temp_path, metadata_path)
+                
+                # Remove temporary file
+                os.remove(temp_path)
+            
+            logger.info(f"Added metadata to 3MF file: {file_path}")
+        except Exception as e:
+            logger.error(f"Error adding metadata to 3MF file: {str(e)}")
+    
+    def get_supported_formats(self) -> List[str]:
+        """Get list of supported export formats."""
+        return list(self.supported_formats.keys())
+    
+    def get_format_description(self, format_name: str) -> str:
+        """Get description of a format."""
+        return self.supported_formats.get(format_name.lower(), "Unknown format")

package/mcp_servers/openscad-mcp-server/legacy/src/utils/format_validator.py

@@ -0,0 +1,206 @@
+import os
+import logging
+import zipfile
+import xml.etree.ElementTree as ET
+from typing import Tuple, Optional, Dict, Any
+
+logger = logging.getLogger(__name__)
+
+class FormatValidator:
+    """Validates 3D model formats for compatibility with printers."""
+    
+    @staticmethod
+    def validate_3mf(file_path: str) -> Tuple[bool, Optional[str]]:
+        """
+        Validate a 3MF file for compatibility with Prusa and Bambu printers.
+        
+        Args:
+            file_path: Path to the 3MF file
+            
+        Returns:
+            Tuple of (is_valid, error_message)
+        """
+        if not os.path.exists(file_path):
+            return False, f"File not found: {file_path}"
+        
+        try:
+            # 3MF files are ZIP archives with XML content
+            with zipfile.ZipFile(file_path, 'r') as zip_ref:
+                # Check for required files
+                required_files = ['3D/3dmodel.model', '[Content_Types].xml']
+                for req_file in required_files:
+                    try:
+                        zip_ref.getinfo(req_file)
+                    except KeyError:
+                        return False, f"Missing required file in 3MF: {req_file}"
+                
+                # Validate 3D model file
+                with zip_ref.open('3D/3dmodel.model') as model_file:
+                    tree = ET.parse(model_file)
+                    root = tree.getroot()
+                    
+                    # Check for required elements
+                    if root.tag != '{http://schemas.microsoft.com/3dmanufacturing/core/2015/02}model':
+                        return False, "Invalid 3MF: Missing model element"
+                    
+                    # Verify resources section exists
+                    resources = root.find('.//{http://schemas.microsoft.com/3dmanufacturing/core/2015/02}resources')
+                    if resources is None:
+                        return False, "Invalid 3MF: Missing resources element"
+                    
+            return True, None
+        except Exception as e:
+            logger.error(f"Error validating 3MF file: {str(e)}")
+            return False, f"Error validating 3MF file: {str(e)}"
+    
+    @staticmethod
+    def validate_amf(file_path: str) -> Tuple[bool, Optional[str]]:
+        """
+        Validate an AMF file for compatibility with printers.
+        
+        Args:
+            file_path: Path to the AMF file
+            
+        Returns:
+            Tuple of (is_valid, error_message)
+        """
+        if not os.path.exists(file_path):
+            return False, f"File not found: {file_path}"
+        
+        try:
+            # Parse the AMF file (XML format)
+            tree = ET.parse(file_path)
+            root = tree.getroot()
+            
+            # Check for required elements
+            if root.tag != 'amf':
+                return False, "Invalid AMF: Missing amf root element"
+            
+            # Check for at least one object
+            objects = root.findall('./object')
+            if not objects:
+                return False, "Invalid AMF: No objects found"
+            
+            # Check that each object has a mesh
+            for obj in objects:
+                mesh = obj.find('./mesh')
+                if mesh is None:
+                    return False, f"Invalid AMF: Object {obj.get('id', 'unknown')} is missing a mesh"
+                
+                # Check for vertices and volumes
+                vertices = mesh.find('./vertices')
+                volumes = mesh.findall('./volume')
+                
+                if vertices is None:
+                    return False, f"Invalid AMF: Mesh in object {obj.get('id', 'unknown')} is missing vertices"
+                
+                if not volumes:
+                    return False, f"Invalid AMF: Mesh in object {obj.get('id', 'unknown')} has no volumes"
+            
+            return True, None
+        except Exception as e:
+            logger.error(f"Error validating AMF file: {str(e)}")
+            return False, f"Error validating AMF file: {str(e)}"
+    
+    @staticmethod
+    def extract_metadata(file_path: str) -> Dict[str, Any]:
+        """
+        Extract metadata from a 3MF or AMF file.
+        
+        Args:
+            file_path: Path to the 3D model file
+            
+        Returns:
+            Dictionary of metadata
+        """
+        metadata = {}
+        
+        # Check file extension
+        ext = os.path.splitext(file_path)[1].lower()
+        
+        try:
+            if ext == '.3mf':
+                with zipfile.ZipFile(file_path, 'r') as zip_ref:
+                    metadata_path = "Metadata/model_metadata.xml"
+                    try:
+                        with zip_ref.open(metadata_path) as f:
+                            tree = ET.parse(f)
+                            root = tree.getroot()
+                            
+                            for meta in root.findall('./meta'):
+                                name = meta.get('name')
+                                if name:
+                                    metadata[name] = meta.text
+                    except KeyError:
+                        # Metadata file doesn't exist
+                        pass
+            
+            elif ext == '.amf':
+                tree = ET.parse(file_path)
+                root = tree.getroot()
+                
+                for meta in root.findall('./metadata'):
+                    name = meta.get('type')
+                    if name:
+                        metadata[name] = meta.text
+        except Exception as e:
+            logger.error(f"Error extracting metadata: {str(e)}")
+        
+        return metadata
+    
+    @staticmethod
+    def check_printer_compatibility(file_path: str, printer_type: str = "prusa") -> Tuple[bool, Optional[str]]:
+        """
+        Check if a 3D model file is compatible with a specific printer type.
+        
+        Args:
+            file_path: Path to the 3D model file
+            printer_type: Type of printer ("prusa" or "bambu")
+            
+        Returns:
+            Tuple of (is_compatible, error_message)
+        """
+        # Check file extension
+        ext = os.path.splitext(file_path)[1].lower()
+        
+        # Validate based on file format
+        if ext == '.3mf':
+            is_valid, error = FormatValidator.validate_3mf(file_path)
+            if not is_valid:
+                return False, error
+            
+            # Additional printer-specific checks
+            if printer_type.lower() == "prusa":
+                # Prusa-specific checks for 3MF
+                # For now, just basic validation is sufficient
+                return True, None
+            
+            elif printer_type.lower() == "bambu":
+                # Bambu-specific checks for 3MF
+                # For now, just basic validation is sufficient
+                return True, None
+            
+            else:
+                return False, f"Unknown printer type: {printer_type}"
+            
+        elif ext == '.amf':
+            is_valid, error = FormatValidator.validate_amf(file_path)
+            if not is_valid:
+                return False, error
+            
+            # Additional printer-specific checks
+            if printer_type.lower() == "prusa":
+                # Prusa-specific checks for AMF
+                # For now, just basic validation is sufficient
+                return True, None
+            
+            elif printer_type.lower() == "bambu":
+                # Bambu-specific checks for AMF
+                # For now, just basic validation is sufficient
+                return True, None
+            
+            else:
+                return False, f"Unknown printer type: {printer_type}"
+            
+        else:
+            return False, f"Unsupported file format for printer compatibility check: {ext}"

package/mcp_servers/openscad-mcp-server/legacy/src/utils/stl_exporter.py

@@ -0,0 +1,140 @@
+import os
+import logging
+import uuid
+import shutil
+from typing import Dict, Any, Optional, Tuple
+
+from src.utils.stl_validator import STLValidator
+
+logger = logging.getLogger(__name__)
+
+class STLExporter:
+    """
+    Handles STL file export and validation for 3D printing.
+    """
+    
+    def __init__(self, openscad_wrapper, output_dir: str):
+        """
+        Initialize the STL exporter.
+        
+        Args:
+            openscad_wrapper: Instance of OpenSCADWrapper for generating STL files
+            output_dir: Directory to store output files
+        """
+        self.openscad_wrapper = openscad_wrapper
+        self.output_dir = output_dir
+        self.stl_dir = os.path.join(output_dir, "stl")
+        
+        # Create directory if it doesn't exist
+        os.makedirs(self.stl_dir, exist_ok=True)
+    
+    def export_stl(self, scad_file: str, parameters: Optional[Dict[str, Any]] = None) -> Tuple[str, bool, Optional[str]]:
+        """
+        Export a SCAD file to STL format.
+        
+        Args:
+            scad_file: Path to the SCAD file
+            parameters: Optional parameters to override in the SCAD file
+            
+        Returns:
+            Tuple of (stl_file_path, is_valid, error_message)
+        """
+        try:
+            # Generate STL file
+            stl_file = self.openscad_wrapper.generate_stl(scad_file, parameters)
+            
+            # Validate STL file
+            is_valid, error = STLValidator.validate_stl(stl_file)
+            
+            if not is_valid:
+                logger.warning(f"STL validation failed: {error}")
+                
+                # Attempt to repair if validation fails
+                repair_success, repair_error = STLValidator.repair_stl(stl_file)
+                if repair_success:
+                    # Validate again after repair
+                    is_valid, error = STLValidator.validate_stl(stl_file)
+                else:
+                    logger.error(f"STL repair failed: {repair_error}")
+            
+            return stl_file, is_valid, error
+        except Exception as e:
+            logger.error(f"Error exporting STL: {str(e)}")
+            return "", False, str(e)
+    
+    def export_stl_with_metadata(self, scad_file: str, parameters: Optional[Dict[str, Any]] = None, 
+                               metadata: Optional[Dict[str, Any]] = None) -> Dict[str, Any]:
+        """
+        Export a SCAD file to STL format and include metadata.
+        
+        Args:
+            scad_file: Path to the SCAD file
+            parameters: Optional parameters to override in the SCAD file
+            metadata: Optional metadata to include with the STL file
+            
+        Returns:
+            Dictionary with STL file information
+        """
+        # Export STL file
+        stl_file, is_valid, error = self.export_stl(scad_file, parameters)
+        
+        # Create metadata file if metadata is provided
+        metadata_file = None
+        if metadata and stl_file:
+            metadata_file = self._create_metadata_file(stl_file, metadata)
+        
+        # Extract model ID from filename
+        model_id = os.path.basename(scad_file).split('.')[0] if scad_file else str(uuid.uuid4())
+        
+        return {
+            "model_id": model_id,
+            "stl_file": stl_file,
+            "is_valid": is_valid,
+            "error": error,
+            "metadata_file": metadata_file,
+            "metadata": metadata
+        }
+    
+    def _create_metadata_file(self, stl_file: str, metadata: Dict[str, Any]) -> str:
+        """Create a metadata file for an STL file."""
+        metadata_file = f"{os.path.splitext(stl_file)[0]}.json"
+        
+        try:
+            import json
+            with open(metadata_file, 'w') as f:
+                json.dump(metadata, f, indent=2)
+            
+            logger.info(f"Created metadata file: {metadata_file}")
+            return metadata_file
+        except Exception as e:
+            logger.error(f"Error creating metadata file: {str(e)}")
+            return ""
+    
+    def copy_stl_to_location(self, stl_file: str, destination: str) -> str:
+        """
+        Copy an STL file to a specified location.
+        
+        Args:
+            stl_file: Path to the STL file
+            destination: Destination path or directory
+            
+        Returns:
+            Path to the copied STL file
+        """
+        try:
+            if not os.path.exists(stl_file):
+                raise FileNotFoundError(f"STL file not found: {stl_file}")
+            
+            # If destination is a directory, create a filename
+            if os.path.isdir(destination):
+                filename = os.path.basename(stl_file)
+                destination = os.path.join(destination, filename)
+            
+            # Copy the file
+            shutil.copy2(stl_file, destination)
+            logger.info(f"Copied STL file to: {destination}")
+            
+            return destination
+        except Exception as e:
+            logger.error(f"Error copying STL file: {str(e)}")
+            return ""