@hybridlabor-api/bdb-hardware-pcb 0.1.0

package/mcp_servers/openscad-mcp-server/legacy/src/nlp/parameter_extractor.py

@@ -0,0 +1,388 @@
+import re
+import logging
+from typing import Dict, Any, Tuple, List, Optional
+import json
+
+logger = logging.getLogger(__name__)
+
+class ParameterExtractor:
+    """
+    Extract parameters from natural language descriptions.
+    Implements dialog flow for collecting specifications and translating them to OpenSCAD parameters.
+    """
+    
+    def __init__(self):
+        """Initialize the parameter extractor."""
+        # Using only millimeters as per project requirements
+        self.unit_conversions = {
+            'mm': 1.0
+        }
+        
+        # Shape recognition patterns with expanded vocabulary
+        self.shape_patterns = {
+            'cube': r'\b(cube|box|square|rectangular|block|cuboid|brick)\b',
+            'sphere': r'\b(sphere|ball|round|circular|globe|orb)\b',
+            'cylinder': r'\b(cylinder|tube|pipe|rod|circular column|pillar|column)\b',
+            'box': r'\b(hollow box|container|case|enclosure|bin|chest|tray)\b',
+            'rounded_box': r'\b(rounded box|rounded container|rounded case|rounded enclosure|smooth box|rounded corners|chamfered box)\b',
+            'cone': r'\b(cone|pyramid|tapered cylinder|funnel)\b',
+            'torus': r'\b(torus|donut|ring|loop|circular ring)\b',
+            'prism': r'\b(prism|triangular prism|wedge|triangular shape)\b',
+            'custom': r'\b(custom|complex|special|unique|combined|composite)\b'
+        }
+        
+        # Parameter recognition patterns with enhanced unit detection
+        self.parameter_patterns = {
+            'width': r'(\d+(?:\.\d+)?)\s*(?:mm|cm|m|in|inch|inches|ft|foot|feet)?\s*(?:wide|width|across|w)',
+            'height': r'(\d+(?:\.\d+)?)\s*(?:mm|cm|m|in|inch|inches|ft|foot|feet)?\s*(?:high|height|tall|h)',
+            'depth': r'(\d+(?:\.\d+)?)\s*(?:mm|cm|m|in|inch|inches|ft|foot|feet)?\s*(?:deep|depth|long|d|length)',
+            'radius': r'(\d+(?:\.\d+)?)\s*(?:mm|cm|m|in|inch|inches|ft|foot|feet)?\s*(?:radius|r)',
+            'diameter': r'(\d+(?:\.\d+)?)\s*(?:mm|cm|m|in|inch|inches|ft|foot|feet)?\s*(?:diameter|dia)',
+            'thickness': r'(\d+(?:\.\d+)?)\s*(?:mm|cm|m|in|inch|inches|ft|foot|feet)?\s*(?:thick|thickness|t)',
+            'segments': r'(\d+)\s*(?:segments|sides|faces|facets|smoothness)',
+            'center': r'\b(centered|center|middle|origin)\b',
+            'angle': r'(\d+(?:\.\d+)?)\s*(?:deg|degree|degrees|°)?\s*(?:angle|rotation|rotate|tilt)',
+            'scale': r'(\d+(?:\.\d+)?)\s*(?:x|times|scale|scaling|factor)',
+            'resolution': r'(\d+(?:\.\d+)?)\s*(?:resolution|quality|detail)'
+        }
+        
+        # Dialog state for multi-turn conversations
+        self.dialog_state = {}
+    
+    def extract_parameters(self, description: str, model_type: Optional[str] = None, 
+                              existing_parameters: Optional[Dict[str, Any]] = None) -> Tuple[str, Dict[str, Any]]:
+        """
+        Extract model type and parameters from a natural language description.
+        
+        Args:
+            description: Natural language description of the 3D object
+            model_type: Optional model type for context (if already known)
+            existing_parameters: Optional existing parameters for context (for modifications)
+            
+        Returns:
+            Tuple of (model_type, parameters)
+        """
+        # Use provided model_type or determine from description
+        if model_type is None:
+            model_type = self._determine_shape_type(description)
+        
+        # Start with existing parameters if provided
+        parameters = existing_parameters.copy() if existing_parameters else {}
+        
+        # Extract parameters based on the shape type
+        new_parameters = self._extract_shape_parameters(description, model_type)
+        
+        # Update parameters with newly extracted ones
+        parameters.update(new_parameters)
+        
+        # Apply default parameters if needed
+        parameters = self._apply_default_parameters(model_type, parameters)
+        
+        logger.info(f"Extracted model type: {model_type}, parameters: {parameters}")
+        return model_type, parameters
+    
+    def extract_parameters_from_modifications(self, modifications: str, model_type: Optional[str] = None, 
+                                               existing_parameters: Optional[Dict[str, Any]] = None) -> Dict[str, Any]:
+        """
+        Extract parameters from modification description with contextual understanding.
+        
+        Args:
+            modifications: Description of modifications to make
+            model_type: Optional model type for context
+            existing_parameters: Optional existing parameters for context
+            
+        Returns:
+            Dictionary of parameters to update
+        """
+        # Start with existing parameters if provided
+        parameters = existing_parameters.copy() if existing_parameters else {}
+        
+        # Extract all possible parameters from the modifications
+        new_parameters = {}
+        for param_name, pattern in self.parameter_patterns.items():
+            matches = re.findall(pattern, modifications, re.IGNORECASE)
+            if matches:
+                # Take the last match if multiple are found
+                value = matches[-1]
+                if isinstance(value, tuple):
+                    value = value[0]  # Extract from capture group
+                new_parameters[param_name] = self._convert_to_mm(value, modifications)
+        
+        # Update parameters with newly extracted ones
+        parameters.update(new_parameters)
+        
+        # Apply contextual understanding based on model type
+        if model_type and not new_parameters:
+            # If no explicit parameters were found, try to infer from context
+            # For now, we'll just log this case since inference is complex
+            logger.info(f"No explicit parameters found in '{modifications}', using existing parameters")
+        
+        logger.info(f"Extracted modification parameters: {parameters}")
+        return parameters
+    
+    def get_missing_parameters(self, model_type: str, parameters: Dict[str, Any]) -> List[str]:
+        """
+        Determine which required parameters are missing for a given model type.
+        
+        Args:
+            model_type: Type of model
+            parameters: Currently extracted parameters
+            
+        Returns:
+            List of missing parameter names
+        """
+        required_params = self._get_required_parameters(model_type)
+        return [param for param in required_params if param not in parameters]
+    
+    def update_dialog_state(self, user_id: str, model_type: Optional[str] = None, 
+                           parameters: Optional[Dict[str, Any]] = None) -> None:
+        """
+        Update the dialog state for a user.
+        
+        Args:
+            user_id: Unique identifier for the user
+            model_type: Optional model type to update
+            parameters: Optional parameters to update
+        """
+        if user_id not in self.dialog_state:
+            self.dialog_state[user_id] = {
+                'model_type': None,
+                'parameters': {},
+                'missing_parameters': [],
+                'current_question': None
+            }
+        
+        if model_type:
+            self.dialog_state[user_id]['model_type'] = model_type
+        
+        if parameters:
+            self.dialog_state[user_id]['parameters'].update(parameters)
+            
+        # Update missing parameters
+        if self.dialog_state[user_id]['model_type']:
+            missing = self.get_missing_parameters(
+                self.dialog_state[user_id]['model_type'],
+                self.dialog_state[user_id]['parameters']
+            )
+            self.dialog_state[user_id]['missing_parameters'] = missing
+    
+    def get_next_question(self, user_id: str) -> Optional[str]:
+        """
+        Get the next question to ask the user based on missing parameters.
+        
+        Args:
+            user_id: Unique identifier for the user
+            
+        Returns:
+            Question string or None if all parameters are collected
+        """
+        if user_id not in self.dialog_state:
+            return "What kind of 3D object would you like to create?"
+        
+        state = self.dialog_state[user_id]
+        
+        # If we don't have a model type yet, ask for it
+        if not state['model_type']:
+            state['current_question'] = "What kind of 3D object would you like to create?"
+            return state['current_question']
+        
+        # If we have missing parameters, ask for the first one
+        if state['missing_parameters']:
+            param = state['missing_parameters'][0]
+            question = self._get_parameter_question(param, state['model_type'])
+            state['current_question'] = question
+            return question
+        
+        # All parameters collected
+        state['current_question'] = None
+        return None
+    
+    def process_answer(self, user_id: str, answer: str) -> Dict[str, Any]:
+        """
+        Process a user's answer to a question.
+        
+        Args:
+            user_id: Unique identifier for the user
+            answer: User's answer to the current question
+            
+        Returns:
+            Updated dialog state
+        """
+        if user_id not in self.dialog_state:
+            # Initialize with default state
+            self.update_dialog_state(user_id)
+        
+        state = self.dialog_state[user_id]
+        current_question = state['current_question']
+        
+        # Process based on current question
+        if not state['model_type']:
+            # Trying to determine the model type
+            model_type = self._determine_shape_type(answer)
+            self.update_dialog_state(user_id, model_type=model_type)
+        elif state['missing_parameters']:
+            # Trying to collect a specific parameter
+            param = state['missing_parameters'][0]
+            value = self._extract_parameter_value(param, answer)
+            if value is not None:
+                self.update_dialog_state(user_id, parameters={param: value})
+        
+        # Return the updated state
+        return self.dialog_state[user_id]
+    
+    def _determine_shape_type(self, description: str) -> str:
+        """
+        Determine the shape type from the description.
+        Enhanced to support more shape types and better pattern matching.
+        """
+        # Check for explicit shape mentions
+        for shape, pattern in self.shape_patterns.items():
+            if re.search(pattern, description, re.IGNORECASE):
+                logger.info(f"Detected shape type: {shape} from pattern: {pattern}")
+                return shape
+        
+        # Try to infer shape from context if no explicit mention
+        if re.search(r'\b(round|circular|sphere|ball)\b', description, re.IGNORECASE):
+            return "sphere"
+        elif re.search(r'\b(tall|column|pillar|rod)\b', description, re.IGNORECASE):
+            return "cylinder"
+        elif re.search(r'\b(box|container|case|enclosure)\b', description, re.IGNORECASE):
+            # Determine if it should be a rounded box
+            if re.search(r'\b(rounded|smooth|chamfered)\b', description, re.IGNORECASE):
+                return "rounded_box"
+            return "box"
+        
+        # Default to cube if no shape is detected
+        logger.info("No specific shape detected, defaulting to cube")
+        return "cube"
+    
+    def _extract_shape_parameters(self, description: str, model_type: str) -> Dict[str, Any]:
+        """Extract parameters for a specific shape type."""
+        parameters = {}
+        
+        # Extract all possible parameters
+        for param_name, pattern in self.parameter_patterns.items():
+            matches = re.findall(pattern, description, re.IGNORECASE)
+            if matches:
+                # Take the last match if multiple are found
+                value = matches[-1]
+                if isinstance(value, tuple):
+                    value = value[0]  # Extract from capture group
+                parameters[param_name] = self._convert_to_mm(value, description)
+        
+        # Special case for diameter -> radius conversion
+        if 'diameter' in parameters and 'radius' not in parameters:
+            parameters['radius'] = parameters['diameter'] / 2
+            del parameters['diameter']
+        
+        # Special case for center parameter
+        if 'center' in parameters:
+            center_value = parameters['center']
+            if isinstance(center_value, (int, float)):
+                # Convert numeric value to boolean string
+                parameters['center'] = 'true' if center_value > 0 else 'false'
+            else:
+                # Convert string value to boolean string
+                center_str = str(center_value).lower()
+                parameters['center'] = 'true' if center_str in ['true', 'yes', 'y', '1'] else 'false'
+        
+        return parameters
+    
+    def _convert_to_mm(self, value_str: str, context: str) -> float:
+        """
+        Convert a value to millimeters.
+        As per project requirements, we only use millimeters for design.
+        """
+        try:
+            value = float(value_str)
+            
+            # Since we're only using millimeters, we just return the value directly
+            # This simplifies the conversion logic while maintaining the function interface
+            logger.info(f"Using value {value} in millimeters")
+            return value
+        except ValueError:
+            logger.warning(f"Could not convert value to float: {value_str}")
+            return 0.0
+    
+    def _apply_default_parameters(self, model_type: str, parameters: Dict[str, Any]) -> Dict[str, Any]:
+        """Apply default parameters based on the model type."""
+        defaults = {
+            'cube': {'width': 10, 'depth': 10, 'height': 10, 'center': 'false'},
+            'sphere': {'radius': 10, 'segments': 32},
+            'cylinder': {'radius': 10, 'height': 20, 'center': 'false', 'segments': 32},
+            'box': {'width': 30, 'depth': 20, 'height': 15, 'thickness': 2},
+            'rounded_box': {'width': 30, 'depth': 20, 'height': 15, 'radius': 3, 'segments': 32},
+            'cone': {'base_radius': 10, 'height': 20, 'center': 'false', 'segments': 32},
+            'torus': {'major_radius': 20, 'minor_radius': 5, 'segments': 32},
+            'prism': {'width': 20, 'height': 15, 'depth': 20, 'center': 'false'},
+            'custom': {'width': 20, 'height': 20, 'depth': 20, 'center': 'false'}
+        }
+        
+        # Get defaults for the model type
+        model_defaults = defaults.get(model_type, {})
+        
+        # Apply defaults for missing parameters
+        for param, default_value in model_defaults.items():
+            if param not in parameters:
+                parameters[param] = default_value
+        
+        return parameters
+    
+    def _get_required_parameters(self, model_type: str) -> List[str]:
+        """Get the list of required parameters for a model type."""
+        required_params = {
+            'cube': ['width', 'depth', 'height'],
+            'sphere': ['radius'],
+            'cylinder': ['radius', 'height'],
+            'box': ['width', 'depth', 'height', 'thickness'],
+            'rounded_box': ['width', 'depth', 'height', 'radius'],
+            'cone': ['base_radius', 'height'],
+            'torus': ['major_radius', 'minor_radius'],
+            'prism': ['width', 'height', 'depth'],
+            'custom': ['width', 'height', 'depth']
+        }
+        
+        return required_params.get(model_type, [])
+    
+    def _get_parameter_question(self, param: str, model_type: str) -> str:
+        """Get a question to ask for a specific parameter."""
+        questions = {
+            'width': f"What should be the width of the {model_type} in mm?",
+            'depth': f"What should be the depth of the {model_type} in mm?",
+            'height': f"What should be the height of the {model_type} in mm?",
+            'radius': f"What should be the radius of the {model_type} in mm?",
+            'thickness': f"What should be the wall thickness of the {model_type} in mm?",
+            'segments': f"How many segments should the {model_type} have for smoothness?",
+            'base_radius': f"What should be the base radius of the {model_type} in mm?",
+            'major_radius': f"What should be the major radius of the {model_type} in mm?",
+            'minor_radius': f"What should be the minor radius of the {model_type} in mm?",
+            'diameter': f"What should be the diameter of the {model_type} in mm?",
+            'angle': f"What should be the angle of the {model_type} in degrees?",
+            'scale': f"What should be the scale factor for the {model_type}?",
+            'resolution': f"What resolution should the {model_type} have (higher means more detailed)?",
+            'center': f"Should the {model_type} be centered? (yes/no)"
+        }
+        
+        return questions.get(param, f"What should be the {param} of the {model_type}?")
+    
+    def _extract_parameter_value(self, param: str, answer: str) -> Optional[float]:
+        """Extract a parameter value from an answer."""
+        pattern = self.parameter_patterns.get(param)
+        if not pattern:
+            # For parameters without specific patterns, try to extract any number
+            pattern = r'(\d+(?:\.\d+)?)'
+        
+        matches = re.findall(pattern, answer, re.IGNORECASE)
+        if matches:
+            value = matches[-1]
+            if isinstance(value, tuple):
+                value = value[0]  # Extract from capture group
+            return self._convert_to_mm(value, answer)
+        
+        # Try to extract just a number
+        matches = re.findall(r'(\d+(?:\.\d+)?)', answer)
+        if matches:
+            value = matches[-1]
+            return self._convert_to_mm(value, answer)
+        
+        return None