Create code_generate.py

code_generate.py

@@ -0,0 +1,106 @@
+from typing import Dict, List, Optional
+import random
+
+class CodeGenerator:
+    """A class to generate function code in multiple programming languages."""
+    
+    # Supported languages and their templates with proper indentation
+    TEMPLATES: Dict[str, str] = {
+        "python": "def {func_name}({params}):\n    {body}",
+        "javascript": "function {func_name}({params}) {{\n    {body}\n}}",
+        "cpp": "{ret_type} {func_name}({params}) {{\n    {body}\n}}",
+        "java": "public class Main {{\n    public static {ret_type} {func_name}({params}) {{\n        {body}\n    }}\n}}",
+        "csharp": "public class Program {{\n    public static {ret_type} {func_name}({params}) {{\n        {body}\n    }}\n}}"
+    }
+
+    # Configuration data
+    FUNCTION_NAMES: List[str] = ["calculate", "processData", "computeValue", "generateOutput"]
+    DEFAULT_PARAMS: Dict[str, str] = {
+        "python": "x: int, y: int",
+        "javascript": "x, y",
+        "cpp": "int x, int y",
+        "java": "int x, int y",
+        "csharp": "int x, int y"
+    }
+    RETURN_TYPES: Dict[str, str] = {
+        "cpp": "int",
+        "java": "int",
+        "csharp": "int",
+        "python": " -> int",  # Type hint for Python
+        "javascript": ""      # No explicit return type
+    }
+    DEFAULT_BODY: str = "return x + y;"
+    
+    def __init__(self, seed: Optional[int] = None):
+        """Initialize generator with optional random seed."""
+        if seed is not None:
+            random.seed(seed)
+
+    def get_supported_languages(self) -> List[str]:
+        """Return list of supported languages."""
+        return list(self.TEMPLATES.keys())
+
+    def generate_code(
+        self,
+        language: str,
+        func_name: Optional[str] = None,
+        params: Optional[str] = None,
+        body: Optional[str] = None,
+        ret_type: Optional[str] = None
+    ) -> Optional[str]:
+        """
+        Generate code for the specified language with customizable components.
+        
+        Args:
+            language: Target programming language
+            func_name: Optional custom function name
+            params: Optional custom parameters
+            body: Optional custom function body
+            ret_type: Optional custom return type
+            
+        Returns:
+            Generated code string or None if language is unsupported
+        """
+        if language not in self.TEMPLATES:
+            return None
+
+        # Use provided values or defaults
+        selected_func_name = func_name or random.choice(self.FUNCTION_NAMES)
+        selected_params = params or self.DEFAULT_PARAMS.get(language, "")
+        selected_body = self._normalize_body(body or self.DEFAULT_BODY, language)
+        selected_ret_type = ret_type or self.RETURN_TYPES.get(language, "")
+
+        try:
+            return self.TEMPLATES[language].format(
+                func_name=selected_func_name,
+                params=selected_params,
+                body=selected_body,
+                ret_type=selected_ret_type
+            )
+        except KeyError as e:
+            raise ValueError(f"Missing template component: {str(e)}")
+        except Exception as e:
+            raise RuntimeError(f"Code generation failed: {str(e)}")
+
+    def _normalize_body(self, body: str, language: str) -> str:
+        """Normalize function body based on language requirements."""
+        body = body.strip()
+        if language in {"cpp", "java", "csharp"} and not body.endswith(";"):
+            return body + ";"
+        if language == "python":
+            return body.replace(";", "")  # Python doesn't use semicolons
+        return body
+
+def main():
+    """Demonstrate code generation for all supported languages."""
+    generator = CodeGenerator(seed=42)  # Fixed seed for reproducibility
+    
+    print("Supported languages:", generator.get_supported_languages())
+    print("\nGenerated code examples:")
+    
+    for lang in generator.get_supported_languages():
+        code = generator.generate_code(lang)
+        print(f"\n{lang.upper()}:\n{code}")
+
+if __name__ == "__main__":
+    main()