@hybridlabor-api/bdb-hardware-pcb 0.1.0

package/mcp_servers/openscad-mcp-server/legacy/src/ai/ai_service.py

@@ -0,0 +1,257 @@
+import os
+import logging
+import re
+from typing import Dict, Any, Optional
+
+logger = logging.getLogger(__name__)
+
+class AIService:
+    """
+    Service for AI-driven OpenSCAD code generation.
+    Translates natural language descriptions into OpenSCAD code.
+    """
+    
+    def __init__(self, templates_dir: str, model_config: Optional[Dict[str, Any]] = None):
+        """
+        Initialize the AI service.
+        
+        Args:
+            templates_dir: Directory containing OpenSCAD templates
+            model_config: Optional configuration for the AI model
+        """
+        self.templates_dir = templates_dir
+        self.model_config = model_config or {}
+        
+        # Load templates
+        self.templates = self._load_templates()
+        
+        logger.info(f"Initialized AI service with {len(self.templates)} templates")
+    
+    def generate_openscad_code(self, context: Dict[str, Any]) -> str:
+        """
+        Generate OpenSCAD code from natural language description.
+        
+        Args:
+            context: Dictionary containing:
+                - description: Natural language description
+                - parameters: Dictionary of parameters
+                - templates_dir: Directory containing templates
+                
+        Returns:
+            Generated OpenSCAD code
+        """
+        description = context.get("description", "")
+        parameters = context.get("parameters", {})
+        
+        logger.info(f"Generating OpenSCAD code for: {description}")
+        
+        # Parse the description to identify key components
+        components = self._parse_description(description)
+        
+        # Generate code based on identified components
+        code = self._generate_code_from_components(components, parameters)
+        
+        return code
+    
+    def _load_templates(self) -> Dict[str, str]:
+        """Load OpenSCAD code templates from the templates directory."""
+        templates = {}
+        
+        # Check if templates directory exists
+        if not os.path.exists(self.templates_dir):
+            logger.warning(f"Templates directory not found: {self.templates_dir}")
+            return templates
+        
+        # Load all .scad files in the templates directory
+        for filename in os.listdir(self.templates_dir):
+            if filename.endswith(".scad"):
+                template_name = os.path.splitext(filename)[0]
+                template_path = os.path.join(self.templates_dir, filename)
+                
+                try:
+                    with open(template_path, 'r') as f:
+                        templates[template_name] = f.read()
+                except Exception as e:
+                    logger.error(f"Error loading template {template_path}: {e}")
+        
+        return templates
+    
+    def _parse_description(self, description: str) -> Dict[str, Any]:
+        """
+        Parse a natural language description to identify key components.
+        
+        Args:
+            description: Natural language description of the model
+            
+        Returns:
+            Dictionary of identified components
+        """
+        components = {
+            "primary_shape": None,
+            "operations": [],
+            "features": [],
+            "modifiers": []
+        }
+        
+        # Identify primary shape
+        shape_patterns = {
+            "cube": r'\b(cube|box|rectangular|block)\b',
+            "sphere": r'\b(sphere|ball|round|circular)\b',
+            "cylinder": r'\b(cylinder|tube|pipe|rod)\b',
+            "cone": r'\b(cone|pyramid|tapered)\b',
+            "torus": r'\b(torus|donut|ring)\b'
+        }
+        
+        for shape, pattern in shape_patterns.items():
+            if re.search(pattern, description, re.IGNORECASE):
+                components["primary_shape"] = shape
+                break
+        
+        # Identify operations
+        operation_patterns = {
+            "union": r'\b(combine|join|merge|add)\b',
+            "difference": r'\b(subtract|remove|cut|hole|hollow)\b',
+            "intersection": r'\b(intersect|common|shared)\b'
+        }
+        
+        for operation, pattern in operation_patterns.items():
+            if re.search(pattern, description, re.IGNORECASE):
+                components["operations"].append(operation)
+        
+        # Identify features
+        feature_patterns = {
+            "rounded_corners": r'\b(rounded corners|fillets|chamfer)\b',
+            "holes": r'\b(holes|perforations|openings)\b',
+            "text": r'\b(text|label|inscription)\b',
+            "pattern": r'\b(pattern|array|grid|repeat)\b'
+        }
+        
+        for feature, pattern in feature_patterns.items():
+            if re.search(pattern, description, re.IGNORECASE):
+                components["features"].append(feature)
+        
+        # Identify modifiers
+        modifier_patterns = {
+            "scale": r'\b(scale|resize|proportion)\b',
+            "rotate": r'\b(rotate|turn|spin|angle)\b',
+            "translate": r'\b(move|shift|position|place)\b',
+            "mirror": r'\b(mirror|reflect|flip)\b'
+        }
+        
+        for modifier, pattern in modifier_patterns.items():
+            if re.search(pattern, description, re.IGNORECASE):
+                components["modifiers"].append(modifier)
+        
+        logger.info(f"Parsed components: {components}")
+        return components
+    
+    def _generate_code_from_components(self, components: Dict[str, Any], parameters: Dict[str, Any]) -> str:
+        """
+        Generate OpenSCAD code based on identified components.
+        
+        Args:
+            components: Dictionary of identified components
+            parameters: Dictionary of parameters
+            
+        Returns:
+            Generated OpenSCAD code
+        """
+        code = []
+        
+        # Add header
+        code.append("// AI-generated OpenSCAD code")
+        code.append("// Generated from natural language description")
+        code.append("")
+        
+        # Add parameter declarations
+        code.append("// Parameters")
+        for param, value in parameters.items():
+            if isinstance(value, str) and not (value.lower() == 'true' or value.lower() == 'false'):
+                code.append(f'{param} = "{value}";')
+            else:
+                code.append(f"{param} = {value};")
+        code.append("")
+        
+        # Generate code for primary shape
+        primary_shape = components.get("primary_shape")
+        if not primary_shape:
+            primary_shape = "cube"  # Default to cube if no shape is identified
+        
+        # Start with operations if any
+        operations = components.get("operations", [])
+        if operations:
+            for operation in operations:
+                code.append(f"{operation}() {{")
+            code.append("    // Primary shape")
+        
+        # Add modifiers if any
+        modifiers = components.get("modifiers", [])
+        indent = "    " if operations else ""
+        
+        if modifiers:
+            for modifier in modifiers:
+                if modifier == "scale":
+                    scale_value = parameters.get("scale", 1)
+                    code.append(f"{indent}scale([{scale_value}, {scale_value}, {scale_value}])")
+                elif modifier == "rotate":
+                    angle = parameters.get("angle", 0)
+                    code.append(f"{indent}rotate([0, 0, {angle}])")
+                elif modifier == "translate":
+                    x = parameters.get("x", 0)
+                    y = parameters.get("y", 0)
+                    z = parameters.get("z", 0)
+                    code.append(f"{indent}translate([{x}, {y}, {z}])")
+                elif modifier == "mirror":
+                    code.append(f"{indent}mirror([0, 0, 1])")
+        
+        # Add the primary shape
+        if primary_shape == "cube":
+            width = parameters.get("width", 10)
+            depth = parameters.get("depth", 10)
+            height = parameters.get("height", 10)
+            center = parameters.get("center", "true")
+            code.append(f"{indent}cube([{width}, {depth}, {height}], center={center});")
+        elif primary_shape == "sphere":
+            radius = parameters.get("radius", 10)
+            segments = parameters.get("segments", 32)
+            code.append(f"{indent}sphere(r={radius}, $fn={segments});")
+        elif primary_shape == "cylinder":
+            radius = parameters.get("radius", 10)
+            height = parameters.get("height", 20)
+            center = parameters.get("center", "true")
+            segments = parameters.get("segments", 32)
+            code.append(f"{indent}cylinder(h={height}, r={radius}, center={center}, $fn={segments});")
+        elif primary_shape == "cone":
+            base_radius = parameters.get("base_radius", 10)
+            height = parameters.get("height", 20)
+            center = parameters.get("center", "true")
+            segments = parameters.get("segments", 32)
+            code.append(f"{indent}cylinder(h={height}, r1={base_radius}, r2=0, center={center}, $fn={segments});")
+        elif primary_shape == "torus":
+            major_radius = parameters.get("major_radius", 20)
+            minor_radius = parameters.get("minor_radius", 5)
+            segments = parameters.get("segments", 32)
+            code.append(f"{indent}rotate_extrude($fn={segments})")
+            code.append(f"{indent}    translate([{major_radius}, 0, 0])")
+            code.append(f"{indent}    circle(r={minor_radius}, $fn={segments});")
+        
+        # Add features if any
+        features = components.get("features", [])
+        if features and "holes" in features:
+            code.append("")
+            code.append(f"{indent}// Add holes")
+            code.append(f"{indent}difference() {{")
+            code.append(f"{indent}    children(0);")  # Reference the primary shape
+            
+            # Add a sample hole
+            hole_radius = parameters.get("hole_radius", 2)
+            code.append(f"{indent}    translate([0, 0, 0])")
+            code.append(f"{indent}    cylinder(h=100, r={hole_radius}, center=true, $fn=32);")
+            
+            code.append(f"{indent}}}")
+        
+        # Close operations if any
+        if operations:
+            code.append("}")
+        
+        return "\n".join(code)

package/mcp_servers/openscad-mcp-server/legacy/src/ai/gemini_api.py

@@ -0,0 +1,161 @@
+"""
+Google Gemini API integration for image generation.
+"""
+
+import os
+import logging
+import base64
+from typing import Dict, Any, List, Optional
+from io import BytesIO
+from PIL import Image
+import requests
+
+logger = logging.getLogger(__name__)
+
+class GeminiImageGenerator:
+    """
+    Wrapper for Google Gemini API for generating images.
+    """
+    
+    def __init__(self, api_key: str, output_dir: str = "output/images"):
+        """
+        Initialize the Gemini image generator.
+        
+        Args:
+            api_key: Google Gemini API key
+            output_dir: Directory to store generated images
+        """
+        self.api_key = api_key
+        self.output_dir = output_dir
+        self.base_url = "https://generativelanguage.googleapis.com/v1beta"
+        
+        # Create output directory if it doesn't exist
+        os.makedirs(output_dir, exist_ok=True)
+    
+    def generate_image(self, prompt: str, model: str = "gemini-2.0-flash-exp-image-generation", 
+                       output_path: Optional[str] = None, **kwargs) -> Dict[str, Any]:
+        """
+        Generate an image using Google Gemini API.
+        
+        Args:
+            prompt: Text description for image generation
+            model: Gemini model to use
+            output_path: Path to save the generated image
+            **kwargs: Additional parameters for Gemini API
+            
+        Returns:
+            Dictionary containing image data and metadata
+        """
+        logger.info(f"Generating image with prompt: {prompt}")
+        
+        try:
+            # Prepare the request payload
+            payload = {
+                "contents": [
+                    {
+                        "parts": [
+                            {"text": prompt}
+                        ]
+                    }
+                ],
+                "generationConfig": {
+                    "responseModalities": ["Text", "Image"]
+                }
+            }
+            
+            # Add any additional parameters
+            for key, value in kwargs.items():
+                if key not in payload:
+                    payload[key] = value
+            
+            # Make API request
+            response = requests.post(
+                f"{self.base_url}/models/{model}:generateContent",
+                headers={
+                    "Content-Type": "application/json",
+                    "x-goog-api-key": self.api_key
+                },
+                json=payload
+            )
+            
+            # Check for errors
+            response.raise_for_status()
+            result = response.json()
+            
+            # Extract image data
+            image_data = None
+            for part in result["candidates"][0]["content"]["parts"]:
+                if "inlineData" in part:
+                    image_data = base64.b64decode(part["inlineData"]["data"])
+                    break
+            
+            if not image_data:
+                raise ValueError("No image was generated in the response")
+            
+            # Save image if output_path is provided
+            if not output_path:
+                # Generate output path if not provided
+                os.makedirs(self.output_dir, exist_ok=True)
+                output_path = os.path.join(self.output_dir, f"{prompt[:20].replace(' ', '_')}.png")
+            
+            # Save image
+            image = Image.open(BytesIO(image_data))
+            image.save(output_path)
+            
+            logger.info(f"Image saved to {output_path}")
+            
+            return {
+                "prompt": prompt,
+                "model": model,
+                "local_path": output_path,
+                "image_data": image_data
+            }
+            
+        except Exception as e:
+            logger.error(f"Error generating image: {str(e)}")
+            raise
+    
+    def generate_multiple_views(self, prompt: str, num_views: int = 4, 
+                              base_image_path: Optional[str] = None,
+                              output_dir: Optional[str] = None) -> List[Dict[str, Any]]:
+        """
+        Generate multiple views of the same 3D object.
+        
+        Args:
+            prompt: Text description of the object
+            num_views: Number of views to generate
+            base_image_path: Optional path to a base image
+            output_dir: Directory to save the generated images
+            
+        Returns:
+            List of dictionaries containing image data and metadata
+        """
+        if not output_dir:
+            output_dir = os.path.join(self.output_dir, prompt[:20].replace(' ', '_'))
+        
+        os.makedirs(output_dir, exist_ok=True)
+        
+        # View directions to include in prompts
+        view_directions = [
+            "front view", "side view from the right", 
+            "side view from the left", "back view",
+            "top view", "bottom view", "45-degree angle view"
+        ]
+        
+        results = []
+        
+        # Generate images for each view direction
+        for i in range(min(num_views, len(view_directions))):
+            view_prompt = f"{prompt} - {view_directions[i]}, same object, consistent style and details"
+            
+            # Generate the image
+            output_path = os.path.join(output_dir, f"view_{i+1}.png")
+            result = self.generate_image(view_prompt, output_path=output_path)
+            
+            # Add view direction to result
+            result["view_direction"] = view_directions[i]
+            result["view_index"] = i + 1
+            
+            results.append(result)
+        
+        return results

package/mcp_servers/openscad-mcp-server/legacy/src/ai/venice_api.py

@@ -0,0 +1,203 @@
+"""
+Venice.ai API client for image generation using the Flux model.
+"""
+
+import os
+import requests
+import logging
+from typing import Dict, Any, Optional, List, Tuple
+from pathlib import Path
+
+logger = logging.getLogger(__name__)
+
+# Venice.ai model mapping and descriptions
+VENICE_MODELS = {
+    # Model name: (aliases, description)
+    "fluently-xl": (
+        ["fast", "quick", "fastest", "speed", "rapid", "efficient"],
+        "Fastest model (2.30s) with good quality"
+    ),
+    "flux-dev": (
+        ["high quality", "detailed", "hq", "best quality", "premium"],
+        "High-quality model with detailed results"
+    ),
+    "flux-dev-uncensored": (
+        ["uncensored", "unfiltered", "unrestricted"],
+        "Uncensored version of the flux-dev model"
+    ),
+    "stable-diffusion-3.5": (
+        ["stable diffusion", "sd3", "sd3.5", "standard"],
+        "Stable Diffusion 3.5 model"
+    ),
+    "pony-realism": (
+        ["realistic", "realism", "pony", "photorealistic"],
+        "Specialized model for realistic outputs"
+    ),
+    "lustify-sdxl": (
+        ["stylized", "artistic", "creative", "lustify"],
+        "Artistic stylization model"
+    ),
+}
+
+class VeniceImageGenerator:
+    """Client for Venice.ai's image generation API."""
+    
+    def __init__(self, api_key: str, output_dir: str = "output/images"):
+        """
+        Initialize the Venice.ai API client.
+        
+        Args:
+            api_key: API key for Venice.ai
+            output_dir: Directory to store generated images
+        """
+        self.api_key = api_key
+        if not self.api_key:
+            logger.warning("No Venice.ai API key provided")
+        
+        # API endpoint from documentation
+        self.base_url = "https://api.venice.ai/api/v1"
+        self.api_endpoint = f"{self.base_url}/image/generate"
+        self.output_dir = output_dir
+        
+        # Create output directory if it doesn't exist
+        os.makedirs(output_dir, exist_ok=True)
+    
+    def map_model_preference(self, preference: str) -> str:
+        """
+        Map a natural language preference to a Venice.ai model name.
+        
+        Args:
+            preference: Natural language description of desired model
+            
+        Returns:
+            Name of the matching Venice.ai model
+        """
+        if not preference or preference.lower() in ["default", "fluently-xl", "fluently xl"]:
+            return "fluently-xl"
+            
+        preference = preference.lower()
+        
+        # Check for exact matches first
+        for model_name in VENICE_MODELS:
+            if model_name.lower() == preference:
+                return model_name
+        
+        # Check for keyword matches
+        for model_name, (aliases, _) in VENICE_MODELS.items():
+            for alias in aliases:
+                if alias in preference:
+                    return model_name
+        
+        # Default to fluently-xl if no match found
+        return "fluently-xl"
+    
+    def generate_image(self, prompt: str, model: str = "fluently-xl", 
+                      width: int = 1024, height: int = 1024,
+                      output_path: Optional[str] = None) -> Dict[str, Any]:
+        """
+        Generate an image using Venice.ai's API.
+        
+        Args:
+            prompt: Text description for image generation
+            model: Model to use - can be a specific model name or natural language description:
+                - "fluently-xl" (default): Fastest model (2.30s) with good quality
+                - "flux-dev": High-quality model with detailed results
+                - "flux-dev-uncensored": Uncensored version of the flux-dev model
+                - "stable-diffusion-3.5": Stable Diffusion 3.5 model
+                - "pony-realism": Specialized model for realistic outputs
+                - "lustify-sdxl": Artistic stylization model
+                - Or use natural language like "high quality", "fastest", "realistic", etc.
+            width: Image width
+            height: Image height
+            output_path: Optional path to save the generated image
+            
+        Returns:
+            Dictionary containing image data and metadata
+        """
+        if not self.api_key:
+            raise ValueError("Venice.ai API key is required")
+        
+        # Map the model preference to a specific model name
+        mapped_model = self.map_model_preference(model)
+        
+        # Prepare request payload
+        payload = {
+            "model": mapped_model,
+            "prompt": prompt,
+            "height": height,
+            "width": width,
+            "steps": 20,
+            "return_binary": False,
+            "hide_watermark": True,  # Remove watermark as requested
+            "format": "png",
+            "embed_exif_metadata": False
+        }
+        
+        # Set up headers with API key
+        headers = {
+            "Authorization": f"Bearer {self.api_key}",
+            "Content-Type": "application/json"
+        }
+        
+        try:
+            # Make API request
+            logger.info(f"Sending request to {self.api_endpoint}")
+            response = requests.post(
+                self.api_endpoint,
+                json=payload,
+                headers=headers
+            )
+            
+            # Check response status
+            if response.status_code != 200:
+                error_msg = f"Error generating image: {response.status_code} - {response.text}"
+                logger.error(error_msg)
+                return {"error": error_msg}
+            
+            # Process response
+            result = response.json()
+            
+            # Add the mapped model to the result
+            result["model"] = mapped_model
+            
+            # Generate output path if not provided
+            if not output_path:
+                # Create a filename based on the prompt
+                filename = f"{prompt[:20].replace(' ', '_')}_{mapped_model}.png"
+                output_path = os.path.join(self.output_dir, filename)
+            
+            # Save image if images array is in the result
+            if "images" in result and len(result["images"]) > 0:
+                image_url = result["images"][0]
+                self._download_image(image_url, output_path)
+                result["local_path"] = output_path
+                result["image_url"] = image_url
+            
+            return result
+        except requests.exceptions.RequestException as e:
+            logger.error(f"Error generating image with Venice.ai: {str(e)}")
+            raise
+    
+    def _download_image(self, image_url: str, output_path: str) -> None:
+        """
+        Download image from URL and save to local path.
+        
+        Args:
+            image_url: URL of the image to download
+            output_path: Path to save the downloaded image
+        """
+        try:
+            response = requests.get(image_url, stream=True)
+            response.raise_for_status()
+            
+            # Ensure directory exists
+            os.makedirs(os.path.dirname(output_path), exist_ok=True)
+            
+            with open(output_path, 'wb') as f:
+                for chunk in response.iter_content(chunk_size=8192):
+                    f.write(chunk)
+            
+            logger.info(f"Image saved to {output_path}")
+        except Exception as e:
+            logger.error(f"Error downloading image: {str(e)}")
+            raise