Update tools/JavaScriptToPythonConverter.py

tools/JavaScriptToPythonConverter.py

@@ -1,207 +1,189 @@
-import esprima  # For parsing JavaScript
-import ast      # For Python AST manipulation
-from typing import Union, Dict, List, Any
+import esprima
+from typing import Any, Callable, Dict, Optional
+import types
+import ast
+import inspect
+from smolagents.tools import Tool
 
-class JavaScriptToPythonConverter:
+class JavaScriptMethodDispatcher(Tool):
+    name = "javascript_as_python_caller"
+    description = "turns java script code blocks into callable python functions"
+    inputs = {'jsContent':{'type':'string', 'description':'content of a regular java script code block of a function definition'}}
+    output_type = "callable"
+    
     def __init__(self):
-        self.variable_map: Dict[str, str] = {}
+        self._method_cache: Dict[str, Callable] = {}
         
-    def convert_js_to_python(self, js_code: str) -> str:
+    def register_js_method(self, js_code: str, method_name: Optional[str] = None) -> Callable:
         """
-        Convert JavaScript code to Python code.
+        Convert JavaScript code to a Python callable and register it in the dispatcher.
         
         Args:
-            js_code (str): JavaScript code to convert
-            
+            js_code (str): JavaScript code containing the function
+            method_name (str, optional): Name to register the method under. 
+                                       If None, tries to extract from the JS code.
+        
         Returns:
-            str: Converted Python code
+            Callable: Python function that can be called directly
         """
         try:
-            # Parse JavaScript code into AST
-            js_ast = esprima.parseScript(js_code)
+            # Parse JavaScript code
+            parsed = esprima.parseScript(js_code)
+            
+            # Find the function declaration
+            func_decl = None
+            for node in parsed.body:
+                if node.type == 'FunctionDeclaration':
+                    func_decl = node
+                    break
+            
+            if not func_decl:
+                raise ValueError("No function declaration found in JavaScript code")
+            
+            # Get the method name
+            if method_name is None:
+                method_name = func_decl.id.name
+            
+            # Convert JavaScript parameters to Python
+            params = [param.name for param in func_decl.params]
             
-            # Convert the AST to Python code
-            python_code = self._convert_node(js_ast)
+            # Convert the function body
+            body_lines = self._convert_js_body(func_decl.body)
             
-            return python_code
+            # Create the Python function source
+            py_source = f"def {method_name}({', '.join(params)}):\n"
+            py_source += "\n".join(f"    {line}" for line in body_lines)
+            
+            # Create function namespace
+            namespace = {
+                'print': print,  # Common built-ins
+                'str': str,
+                'int': int,
+                'float': float,
+                'bool': bool,
+                'list': list,
+                'dict': dict,
+                'None': None,
+                'True': True,
+                'False': False
+            }
+            
+            # Compile and execute the Python code
+            compiled_code = compile(py_source, '<string>', 'exec')
+            exec(compiled_code, namespace)
+            
+            # Get the compiled function
+            py_func = namespace[method_name]
+            
+            # Store in cache
+            self._method_cache[method_name] = py_func
+            
+            return py_func
             
         except Exception as e:
-            raise ValueError(f"Failed to convert JavaScript code: {str(e)}")
+            raise ValueError(f"Failed to convert JavaScript method: {str(e)}")
     
-    def _convert_node(self, node: Any) -> str:
-        """Convert a JavaScript AST node to Python code."""
-        node_type = node.type if hasattr(node, 'type') else type(node).__name__
-        
-        # Map of JavaScript node types to conversion methods
-        converters = {
-            'Program': self._convert_program,
-            'VariableDeclaration': self._convert_variable_declaration,
-            'FunctionDeclaration': self._convert_function_declaration,
-            'ExpressionStatement': self._convert_expression_statement,
-            'BinaryExpression': self._convert_binary_expression,
-            'Identifier': self._convert_identifier,
-            'Literal': self._convert_literal,
-            'CallExpression': self._convert_call_expression,
-            'ReturnStatement': self._convert_return_statement,
-            'IfStatement': self._convert_if_statement,
-            'ForStatement': self._convert_for_statement,
-            'WhileStatement': self._convert_while_statement
-        }
-        
-        converter = converters.get(node_type)
-        if converter:
-            return converter(node)
-        else:
-            raise ValueError(f"Unsupported node type: {node_type}")
-    
-    def _convert_program(self, node: Any) -> str:
-        """Convert a JavaScript program node to Python code."""
-        return '\n'.join(self._convert_node(stmt) for stmt in node.body)
-    
-    def _convert_variable_declaration(self, node: Any) -> str:
-        """Convert JavaScript variable declarations to Python assignments."""
-        declarations = []
-        for decl in node.declarations:
-            var_name = decl.id.name
-            self.variable_map[var_name] = var_name
-            
-            if decl.init:
-                init = self._convert_node(decl.init)
-                declarations.append(f"{var_name} = {init}")
-            else:
-                declarations.append(f"{var_name} = None")
+    def get_method(self, method_name: str) -> Optional[Callable]:
+        """
+        Get a registered method by name.
         
-        return '\n'.join(declarations)
+        Args:
+            method_name (str): Name of the registered method
+            
+        Returns:
+            Optional[Callable]: The registered Python function, or None if not found
+        """
+        return self._method_cache.get(method_name)
     
-    def _convert_function_declaration(self, node: Any) -> str:
-        """Convert JavaScript function declarations to Python functions."""
-        func_name = node.id.name
-        params = [param.name for param in node.params]
-        body = self._convert_node(node.body)
+    def call_method(self, method_name: str, *args, **kwargs) -> Any:
+        """
+        Call a registered method by name with given arguments.
         
-        return f"def {func_name}({', '.join(params)}):\n{self._indent(body)}"
-    
-    def _convert_expression_statement(self, node: Any) -> str:
-        """Convert JavaScript expression statements to Python."""
-        return self._convert_node(node.expression)
+        Args:
+            method_name (str): Name of the registered method
+            *args: Positional arguments to pass to the method
+            **kwargs: Keyword arguments to pass to the method
+            
+        Returns:
+            Any: Result of the method call
+            
+        Raises:
+            ValueError: If method is not found or call fails
+        """
+        method = self.get_method(method_name)
+        if method is None:
+            raise ValueError(f"Method '{method_name}' not found")
+            
+        try:
+            return method(*args, **kwargs)
+        except Exception as e:
+            raise ValueError(f"Failed to call method '{method_name}': {str(e)}")
     
-    def _convert_binary_expression(self, node: Any) -> str:
-        """Convert JavaScript binary expressions to Python."""
-        operator_map = {
-            '===': '==',
-            '!==': '!=',
-            '&&': 'and',
-            '||': 'or'
-        }
+    def _convert_js_body(self, body_node: Any) -> list[str]:
+        """Convert JavaScript function body to Python code lines."""
+        # This is a simplified conversion - you'd want to expand this
+        # based on your specific needs
+        lines = []
         
-        left = self._convert_node(node.left)
-        right = self._convert_node(node.right)
-        op = operator_map.get(node.operator, node.operator)
+        # Handle different types of statements
+        if body_node.type == 'BlockStatement':
+            for statement in body_node.body:
+                if statement.type == 'ReturnStatement':
+                    return_value = self._convert_js_expression(statement.argument)
+                    lines.append(f"return {return_value}")
+                elif statement.type == 'ExpressionStatement':
+                    expr = self._convert_js_expression(statement.expression)
+                    lines.append(expr)
+                elif statement.type == 'IfStatement':
+                    condition = self._convert_js_expression(statement.test)
+                    lines.append(f"if {condition}:")
+                    then_lines = self._convert_js_body(statement.consequent)
+                    lines.extend(f"    {line}" for line in then_lines)
+                    if statement.alternate:
+                        lines.append("else:")
+                        else_lines = self._convert_js_body(statement.alternate)
+                        lines.extend(f"    {line}" for line in else_lines)
         
-        return f"{left} {op} {right}"
-    
-    def _convert_identifier(self, node: Any) -> str:
-        """Convert JavaScript identifiers to Python."""
-        name = node.name
-        # Map JavaScript built-ins to Python equivalents
-        js_to_python_builtins = {
-            'console.log': 'print',
-            'undefined': 'None',
-            'null': 'None',
-            'true': 'True',
-            'false': 'False'
-        }
-        return js_to_python_builtins.get(name, name)
-    
-    def _convert_literal(self, node: Any) -> str:
-        """Convert JavaScript literals to Python literals."""
-        if node.value is None:
-            return 'None'
-        elif isinstance(node.value, (int, float)):
-            return str(node.value)
-        elif isinstance(node.value, str):
-            return repr(node.value)
-        elif isinstance(node.value, bool):
+        return lines
+    
+    def _convert_js_expression(self, node: Any) -> str:
+        """Convert JavaScript expression to Python code string."""
+        if node.type == 'BinaryExpression':
+            left = self._convert_js_expression(node.left)
+            right = self._convert_js_expression(node.right)
+            op = node.operator
+            # Convert JavaScript operators to Python
+            op_map = {
+                '===': '==',
+                '!==': '!=',
+                '&&': 'and',
+                '||': 'or'
+            }
+            op = op_map.get(op, op)
+            return f"({left} {op} {right})"
+        elif node.type == 'Literal':
+            if isinstance(node.value, str):
+                return f"'{node.value}'"
             return str(node.value)
-        else:
-            raise ValueError(f"Unsupported literal type: {type(node.value)}")
-    
-    def _convert_call_expression(self, node: Any) -> str:
-        """Convert JavaScript function calls to Python."""
-        callee = self._convert_node(node.callee)
-        args = [self._convert_node(arg) for arg in node.arguments]
-        
-        # Handle special cases
-        if callee == 'console.log':
-            callee = 'print'
-        
-        return f"{callee}({', '.join(args)})"
-    
-    def _convert_return_statement(self, node: Any) -> str:
-        """Convert JavaScript return statements to Python."""
-        if node.argument:
-            return f"return {self._convert_node(node.argument)}"
-        return "return"
-    
-    def _convert_if_statement(self, node: Any) -> str:
-        """Convert JavaScript if statements to Python."""
-        test = self._convert_node(node.test)
-        consequent = self._convert_node(node.consequent)
-        
-        if_stmt = f"if {test}:\n{self._indent(consequent)}"
-        
-        if node.alternate:
-            alternate = self._convert_node(node.alternate)
-            if_stmt += f"\nelse:\n{self._indent(alternate)}"
-        
-        return if_stmt
-    
-    def _convert_for_statement(self, node: Any) -> str:
-        """Convert JavaScript for loops to Python."""
-        init = self._convert_node(node.init) if node.init else ""
-        test = self._convert_node(node.test) if node.test else "True"
-        update = self._convert_node(node.update) if node.update else ""
-        body = self._convert_node(node.body)
+        elif node.type == 'Identifier':
+            # Handle JavaScript built-ins
+            js_to_py = {
+                'undefined': 'None',
+                'null': 'None',
+                'true': 'True',
+                'false': 'False'
+            }
+            return js_to_py.get(node.name, node.name)
+        elif node.type == 'CallExpression':
+            func = self._convert_js_expression(node.callee)
+            args = [self._convert_js_expression(arg) for arg in node.arguments]
+            # Handle special cases
+            if func == 'console.log':
+                func = 'print'
+            return f"{func}({', '.join(args)})"
         
-        # Convert C-style for loop to while loop
-        if init:
-            return f"{init}\nwhile {test}:\n{self._indent(body)}\n{self._indent(update)}"
-        else:
-            return f"while {test}:\n{self._indent(body)}"
-    
-    def _convert_while_statement(self, node: Any) -> str:
-        """Convert JavaScript while loops to Python."""
-        test = self._convert_node(node.test)
-        body = self._convert_node(node.body)
-        
-        return f"while {test}:\n{self._indent(body)}"
-    
-    def _indent(self, code: str, level: int = 1) -> str:
-        """Indent Python code by specified number of levels."""
-        lines = code.split('\n')
-        return '\n'.join('    ' * level + line for line in lines)
+        raise ValueError(f"Unsupported expression type: {node.type}")
 
+    def forward(self, jsContent: str) -> callable:
+        return self.register_js_method(jsContent)
 
-# Example usage
-if __name__ == "__main__":
-    converter = JavaScriptToPythonConverter()
-    
-    # Example JavaScript code
-    js_code = """
-    function fibonacci(n) {
-        if (n <= 1) {
-            return n;
-        }
-        return fibonacci(n - 1) + fibonacci(n - 2);
-    }
-    
-    var result = fibonacci(10);
-    console.log("Fibonacci result:", result);
-    """
-    
-    try:
-        python_code = converter.convert_js_to_python(js_code)
-        print("Converted Python code:")
-        print(python_code)
-    except Exception as e:
-        print(f"Conversion error: {str(e)}")