pyreact-framework 1.0.0__py3-none-any.whl

pyreact/devtools/debugger.py

@@ -0,0 +1,314 @@
+"""
+Debugger Module
+===============
+
+Debugging tools for PyReact components.
+"""
+
+from typing import Any, Dict, List, Optional
+import time
+
+
+class Debugger:
+    """
+    Debugger for PyReact components
+    
+    Provides tools for inspecting component trees,
+    state, props, and lifecycle events.
+    
+    Example:
+        debugger = Debugger()
+        debugger.enable()
+        
+        # Inspect component
+        debugger.inspect_component(component)
+        
+        # Get component tree
+        tree = debugger.get_tree()
+    """
+    
+    def __init__(self):
+        self._enabled: bool = False
+        self._components: Dict[int, Dict] = {}
+        self._logs: List[Dict] = []
+        self._breakpoints: Dict[str, List[str]] = {}
+        self._watch_list: List[str] = []
+    
+    def enable(self) -> None:
+        """Enable debugging"""
+        self._enabled = True
+    
+    def disable(self) -> None:
+        """Disable debugging"""
+        self._enabled = False
+    
+    def is_enabled(self) -> bool:
+        """Check if debugging is enabled"""
+        return self._enabled
+    
+    def log(self, message: str, data: Optional[Dict] = None) -> None:
+        """
+        Log a debug message
+        
+        Args:
+            message: Log message
+            data: Optional data
+        """
+        if not self._enabled:
+            return
+        
+        entry = {
+            'timestamp': time.time(),
+            'message': message,
+            'data': data or {}
+        }
+        self._logs.append(entry)
+        
+        # Print to console
+        print(f"[PyReact Debug] {message}")
+        if data:
+            print(f"  Data: {data}")
+    
+    def register_component(self, component: Any) -> None:
+        """
+        Register a component for debugging
+        
+        Args:
+            component: Component instance
+        """
+        if not self._enabled:
+            return
+        
+        component_id = id(component)
+        self._components[component_id] = {
+            'component': component,
+            'name': component.__class__.__name__,
+            'props': {},
+            'state': {},
+            'lifecycle_events': [],
+            'render_count': 0,
+            'created_at': time.time()
+        }
+        
+        self.log(f"Component registered: {component.__class__.__name__}")
+    
+    def unregister_component(self, component: Any) -> None:
+        """
+        Unregister a component
+        
+        Args:
+            component: Component instance
+        """
+        component_id = id(component)
+        if component_id in self._components:
+            del self._components[component_id]
+            self.log(f"Component unregistered: {component.__class__.__name__}")
+    
+    def update_component_state(
+        self,
+        component: Any,
+        state: Dict[str, Any]
+    ) -> None:
+        """
+        Update component state in debug view
+        
+        Args:
+            component: Component instance
+            state: Current state
+        """
+        if not self._enabled:
+            return
+        
+        component_id = id(component)
+        if component_id in self._components:
+            self._components[component_id]['state'] = state.copy()
+    
+    def update_component_props(
+        self,
+        component: Any,
+        props: Dict[str, Any]
+    ) -> None:
+        """
+        Update component props in debug view
+        
+        Args:
+            component: Component instance
+            props: Current props
+        """
+        if not self._enabled:
+            return
+        
+        component_id = id(component)
+        if component_id in self._components:
+            self._components[component_id]['props'] = props.copy()
+    
+    def log_lifecycle_event(
+        self,
+        component: Any,
+        event: str,
+        data: Optional[Dict] = None
+    ) -> None:
+        """
+        Log a lifecycle event
+        
+        Args:
+            component: Component instance
+            event: Event name
+            data: Optional data
+        """
+        if not self._enabled:
+            return
+        
+        component_id = id(component)
+        if component_id in self._components:
+            self._components[component_id]['lifecycle_events'].append({
+                'event': event,
+                'timestamp': time.time(),
+                'data': data
+            })
+            
+            # Increment render count
+            if event == 'render':
+                self._components[component_id]['render_count'] += 1
+        
+        self.log(f"Lifecycle: {component.__class__.__name__}.{event}", data)
+    
+    def get_component_info(self, component: Any) -> Optional[Dict]:
+        """
+        Get debug info for a component
+        
+        Args:
+            component: Component instance
+        
+        Returns:
+            dict or None: Component debug info
+        """
+        component_id = id(component)
+        return self._components.get(component_id)
+    
+    def get_tree(self) -> Dict:
+        """
+        Get the component tree
+        
+        Returns:
+            dict: Component tree structure
+        """
+        tree = {'name': 'root', 'children': []}
+        
+        for info in self._components.values():
+            tree['children'].append({
+                'name': info['name'],
+                'props': info['props'],
+                'state': info['state'],
+                'render_count': info['render_count']
+            })
+        
+        return tree
+    
+    def get_logs(self, limit: int = 100) -> List[Dict]:
+        """
+        Get debug logs
+        
+        Args:
+            limit: Maximum number of logs
+        
+        Returns:
+            list: Recent logs
+        """
+        return self._logs[-limit:]
+    
+    def clear_logs(self) -> None:
+        """Clear debug logs"""
+        self._logs.clear()
+    
+    def add_breakpoint(self, component_name: str, event: str) -> None:
+        """
+        Add a breakpoint
+        
+        Args:
+            component_name: Component class name
+            event: Event to break on
+        """
+        if component_name not in self._breakpoints:
+            self._breakpoints[component_name] = []
+        self._breakpoints[component_name].append(event)
+    
+    def remove_breakpoint(self, component_name: str, event: str) -> None:
+        """
+        Remove a breakpoint
+        
+        Args:
+            component_name: Component class name
+            event: Event
+        """
+        if component_name in self._breakpoints:
+            if event in self._breakpoints[component_name]:
+                self._breakpoints[component_name].remove(event)
+    
+    def should_break(self, component_name: str, event: str) -> bool:
+        """
+        Check if should break
+        
+        Args:
+            component_name: Component class name
+            event: Event
+        
+        Returns:
+            bool: True if should break
+        """
+        return (
+            component_name in self._breakpoints and
+            event in self._breakpoints[component_name]
+        )
+    
+    def watch(self, expression: str) -> None:
+        """
+        Add expression to watch list
+        
+        Args:
+            expression: Expression to watch
+        """
+        if expression not in self._watch_list:
+            self._watch_list.append(expression)
+    
+    def unwatch(self, expression: str) -> None:
+        """
+        Remove expression from watch list
+        
+        Args:
+            expression: Expression to remove
+        """
+        if expression in self._watch_list:
+            self._watch_list.remove(expression)
+
+
+# Global debugger instance
+_debugger = Debugger()
+
+
+def get_debugger() -> Debugger:
+    """Get the global debugger"""
+    return _debugger
+
+
+def debug_component(component: Any) -> Dict:
+    """
+    Get debug info for a component
+    
+    Args:
+        component: Component instance
+    
+    Returns:
+        dict: Component debug info
+    """
+    return _debugger.get_component_info(component) or {}
+
+
+def get_component_tree() -> Dict:
+    """
+    Get the component tree
+    
+    Returns:
+        dict: Component tree
+    """
+    return _debugger.get_tree()

pyreact/devtools/profiler.py

@@ -0,0 +1,288 @@
+"""
+Profiler Module
+===============
+
+Performance profiling for PyReact components.
+"""
+
+from typing import Any, Dict, List, Optional
+import time
+
+
+class Profiler:
+    """
+    Profiler for measuring component performance
+    
+    Tracks render times, commit times, and identifies
+    performance bottlenecks.
+    
+    Example:
+        profiler = Profiler()
+        profiler.start()
+        
+        # ... render components ...
+        
+        profiler.stop()
+        report = profiler.get_report()
+    """
+    
+    def __init__(self):
+        self._enabled: bool = False
+        self._current_phase: Optional[str] = None
+        self._measurements: List[Dict] = []
+        self._component_times: Dict[str, List[float]] = {}
+        self._render_times: List[float] = []
+        self._commit_times: List[float] = []
+        self._start_time: float = 0
+        self._phase_start: float = 0
+    
+    def start(self) -> None:
+        """Start profiling"""
+        self._enabled = True
+        self._start_time = time.time()
+        self.log("Profiler started")
+    
+    def stop(self) -> None:
+        """Stop profiling"""
+        self._enabled = False
+        self.log("Profiler stopped")
+    
+    def is_enabled(self) -> bool:
+        """Check if profiling is enabled"""
+        return self._enabled
+    
+    def begin_render(self, component_name: str) -> None:
+        """
+        Begin measuring render phase
+        
+        Args:
+            component_name: Name of component being rendered
+        """
+        if not self._enabled:
+            return
+        
+        self._current_phase = 'render'
+        self._phase_start = time.time()
+        
+        self._measurements.append({
+            'type': 'render_begin',
+            'component': component_name,
+            'timestamp': self._phase_start
+        })
+    
+    def end_render(self, component_name: str) -> float:
+        """
+        End measuring render phase
+        
+        Args:
+            component_name: Name of component
+        
+        Returns:
+            float: Render time in milliseconds
+        """
+        if not self._enabled:
+            return 0
+        
+        end_time = time.time()
+        render_time = (end_time - self._phase_start) * 1000  # Convert to ms
+        
+        self._render_times.append(render_time)
+        
+        if component_name not in self._component_times:
+            self._component_times[component_name] = []
+        self._component_times[component_name].append(render_time)
+        
+        self._measurements.append({
+            'type': 'render_end',
+            'component': component_name,
+            'timestamp': end_time,
+            'duration': render_time
+        })
+        
+        self._current_phase = None
+        return render_time
+    
+    def begin_commit(self) -> None:
+        """Begin measuring commit phase"""
+        if not self._enabled:
+            return
+        
+        self._current_phase = 'commit'
+        self._phase_start = time.time()
+    
+    def end_commit(self) -> float:
+        """
+        End measuring commit phase
+        
+        Returns:
+            float: Commit time in milliseconds
+        """
+        if not self._enabled:
+            return 0
+        
+        end_time = time.time()
+        commit_time = (end_time - self._phase_start) * 1000
+        
+        self._commit_times.append(commit_time)
+        
+        self._measurements.append({
+            'type': 'commit',
+            'timestamp': end_time,
+            'duration': commit_time
+        })
+        
+        self._current_phase = None
+        return commit_time
+    
+    def log(self, message: str, data: Optional[Dict] = None) -> None:
+        """
+        Log a profiling message
+        
+        Args:
+            message: Log message
+            data: Optional data
+        """
+        if not self._enabled:
+            return
+        
+        self._measurements.append({
+            'type': 'log',
+            'message': message,
+            'data': data or {},
+            'timestamp': time.time()
+        })
+    
+    def get_report(self) -> Dict:
+        """
+        Get profiling report
+        
+        Returns:
+            dict: Profiling report
+        """
+        total_render_time = sum(self._render_times)
+        total_commit_time = sum(self._commit_times)
+        
+        # Calculate component statistics
+        component_stats = {}
+        for name, times in self._component_times.items():
+            if times:
+                component_stats[name] = {
+                    'count': len(times),
+                    'total': sum(times),
+                    'average': sum(times) / len(times),
+                    'min': min(times),
+                    'max': max(times)
+                }
+        
+        return {
+            'total_time': (time.time() - self._start_time) * 1000,
+            'render_time': total_render_time,
+            'commit_time': total_commit_time,
+            'render_count': len(self._render_times),
+            'commit_count': len(self._commit_times),
+            'average_render_time': total_render_time / len(self._render_times) if self._render_times else 0,
+            'average_commit_time': total_commit_time / len(self._commit_times) if self._commit_times else 0,
+            'component_stats': component_stats,
+            'measurements': self._measurements[-100:]  # Last 100 measurements
+        }
+    
+    def get_slow_components(self, threshold: float = 16.0) -> List[Dict]:
+        """
+        Get components that exceed threshold
+        
+        Args:
+            threshold: Threshold in milliseconds (default: 16ms for 60fps)
+        
+        Returns:
+            list: Slow components
+        """
+        slow = []
+        for name, times in self._component_times.items():
+            avg_time = sum(times) / len(times) if times else 0
+            if avg_time > threshold:
+                slow.append({
+                    'name': name,
+                    'average_time': avg_time,
+                    'count': len(times),
+                    'max_time': max(times)
+                })
+        
+        return sorted(slow, key=lambda x: x['average_time'], reverse=True)
+    
+    def clear(self) -> None:
+        """Clear profiling data"""
+        self._measurements.clear()
+        self._component_times.clear()
+        self._render_times.clear()
+        self._commit_times.clear()
+    
+    def export(self) -> str:
+        """
+        Export profiling data as JSON
+        
+        Returns:
+            str: JSON string
+        """
+        import json
+        return json.dumps(self.get_report(), indent=2)
+
+
+# Global profiler instance
+_profiler = Profiler()
+
+
+def get_profiler() -> Profiler:
+    """Get the global profiler"""
+    return _profiler
+
+
+def profile_component(component: Any) -> Dict:
+    """
+    Profile a single component
+    
+    Args:
+        component: Component instance
+    
+    Returns:
+        dict: Component profile data
+    """
+    name = component.__class__.__name__
+    times = _profiler._component_times.get(name, [])
+    
+    if times:
+        return {
+            'name': name,
+            'count': len(times),
+            'total': sum(times),
+            'average': sum(times) / len(times),
+            'min': min(times),
+            'max': max(times)
+        }
+    
+    return {'name': name, 'count': 0}
+
+
+def get_profile_data() -> Dict:
+    """
+    Get all profile data
+    
+    Returns:
+        dict: Profile data
+    """
+    return _profiler.get_report()
+
+
+def start_profiling() -> None:
+    """Start profiling"""
+    _profiler.start()
+
+
+def stop_profiling() -> Dict:
+    """
+    Stop profiling and get report
+    
+    Returns:
+        dict: Profiling report
+    """
+    _profiler.stop()
+    return _profiler.get_report()

pyreact/dom/__init__.py

@@ -0,0 +1,64 @@
+"""
+PyReact DOM Module
+==================
+
+This module provides DOM-specific functionality:
+- DOM operations (create, update, remove elements)
+- Synthetic events (cross-browser event handling)
+- Attribute mapping (HTML attributes vs DOM properties)
+"""
+
+from .dom_operations import (
+    create_element,
+    create_text_node,
+    append_child,
+    remove_child,
+    insert_before,
+    set_attribute,
+    remove_attribute,
+    set_style,
+    add_event_listener,
+    remove_event_listener,
+)
+
+from .events import (
+    SyntheticEvent,
+    SyntheticMouseEvent,
+    SyntheticKeyboardEvent,
+    SyntheticFocusEvent,
+    SyntheticFormEvent,
+    EVENT_TYPES,
+)
+
+from .attributes import (
+    is_custom_attribute,
+    should_set_attribute,
+    get_attribute_name,
+    PROPERTY_NAMES,
+)
+
+__all__ = [
+    # DOM Operations
+    'create_element',
+    'create_text_node',
+    'append_child',
+    'remove_child',
+    'insert_before',
+    'set_attribute',
+    'remove_attribute',
+    'set_style',
+    'add_event_listener',
+    'remove_event_listener',
+    # Events
+    'SyntheticEvent',
+    'SyntheticMouseEvent',
+    'SyntheticKeyboardEvent',
+    'SyntheticFocusEvent',
+    'SyntheticFormEvent',
+    'EVENT_TYPES',
+    # Attributes
+    'is_custom_attribute',
+    'should_set_attribute',
+    'get_attribute_name',
+    'PROPERTY_NAMES',
+]