提交到pi

py_enjoy/proxy/ProxyCompiler.py

@@ -0,0 +1,143 @@
+#!/usr/bin/env python3.9
+# -*- coding: utf-8 -*-
+"""
+JFinal ProxyCompiler - Dynamic Proxy Compiler
+"""
+
+import os
+import tempfile
+import subprocess
+import hashlib
+from typing import Dict, Optional, List, Tuple
+from .ProxyClass import ProxyClass
+from .ProxyClassLoader import ProxyClassLoader
+
+class ProxyCompiler:
+    """Dynamic proxy compiler"""
+    
+    def __init__(self):
+        """Initialize proxy compiler"""
+        self._class_loader = ProxyClassLoader()
+        self._compile_options: List[str] = []
+    
+    def compile(self, proxy_class: ProxyClass):
+        """
+        Compile proxy class source code to byte code
+        
+        Args:
+            proxyClass: ProxyClass object with source code
+        """
+        if not proxy_class.source_code:
+            raise ValueError("Proxy class source code is not set")
+        
+        try:
+            # Generate byte code by compiling Python source
+            byte_code = self._compile_python_source(proxy_class)
+            
+            # Set the byte code
+            proxy_class.byte_code = {
+                proxy_class.full_name: byte_code
+            }
+            
+        except Exception as e:
+            raise RuntimeError(f"Error compiling proxy class: {e}")
+    
+    def _compile_python_source(self, proxy_class: ProxyClass) -> bytes:
+        """
+        Compile Python source code to bytecode
+        
+        Args:
+            proxyClass: ProxyClass with source code
+            
+        Returns:
+            Compiled bytecode
+        """
+        # Method 1: Use compile() and exec()
+        try:
+            # Compile the source code
+            compiled = compile(proxy_class.source_code, proxy_class.name, 'exec')
+            
+            # Create a namespace and execute
+            namespace = {}
+            exec(compiled, namespace)
+            
+            # For Python, bytecode is already loaded in the namespace
+            # Return dummy byte code since Python doesn't have traditional bytecode like Java
+            return b'PYTHON_PROXY_CLASS'
+            
+        except SyntaxError as e:
+            raise RuntimeError(f"Syntax error in generated code: {e}")
+        except Exception as e:
+            raise RuntimeError(f"Error compiling Python source: {e}")
+    
+    def set_compile_options(self, options: List[str]) -> 'ProxyCompiler':
+        """
+        Set compile options
+        
+        Args:
+            options: List of compiler options
+            
+        Returns:
+            Self for chaining
+        """
+        self._compile_options = options.copy()
+        return self
+    
+    def add_compile_option(self, option: str) -> 'ProxyCompiler':
+        """
+        Add single compile option
+        
+        Args:
+            option: Compiler option
+            
+        Returns:
+            Self for chaining
+        """
+        if option:
+            self._compile_options.append(option)
+        return self
+    
+    def get_class_loader(self) -> ProxyClassLoader:
+        """Get associated class loader"""
+        return self._class_loader
+    
+    def compile_and_load(self, proxy_class: ProxyClass) -> type:
+        """
+        Compile proxy class and load the resulting class
+        
+        Args:
+            proxyClass: ProxyClass with source code
+            
+        Returns:
+            Loaded proxy class
+        """
+        # Compile
+        self.compile(proxy_class)
+        
+        # Load
+        return self._class_loader.load_proxy_class(proxy_class)
+
+
+class JavaProxyCompiler:
+    """Compiler for Java proxy classes (for Jython compatibility)"""
+    
+    def __init__(self):
+        """Initialize Java proxy compiler"""
+        self._options: List[str] = []
+    
+    def compile(self, proxy_class: ProxyClass):
+        """Compile Java proxy class"""
+        # This would use javax.tools.JavaCompiler in Java version
+        # For Python, we provide a stub implementation
+        pass
+    
+    def set_options(self, options: List[str]) -> 'JavaProxyCompiler':
+        """Set compiler options"""
+        self._options = options.copy()
+        return self
+    
+    def add_option(self, option: str) -> 'JavaProxyCompiler':
+        """Add compiler option"""
+        if option:
+            self._options.append(option)
+        return self