python2mobile 1.0.1__py3-none-any.whl

p2m/core/runtime.py

@@ -0,0 +1,128 @@
+"""
+P2M Runtime Engine - Executes Python code in a safe sandbox
+"""
+
+import sys
+import ast
+import inspect
+from typing import Any, Callable, Dict, Optional
+from pathlib import Path
+
+
+class Runtime:
+    """Safe Python runtime for executing user code"""
+    
+    def __init__(self, sandbox: bool = True):
+        self.sandbox = sandbox
+        self.globals: Dict[str, Any] = {}
+        self.locals: Dict[str, Any] = {}
+        self._setup_sandbox()
+    
+    def _setup_sandbox(self) -> None:
+        """Setup sandbox environment with allowed builtins"""
+        if self.sandbox:
+            # Restricted builtins for safety
+            allowed_builtins = {
+                "abs", "all", "any", "ascii", "bin", "bool", "bytearray",
+                "bytes", "chr", "dict", "dir", "divmod", "enumerate", "filter",
+                "float", "format", "frozenset", "getattr", "hasattr", "hash",
+                "hex", "id", "int", "isinstance", "issubclass", "iter", "len",
+                "list", "map", "max", "min", "next", "object", "oct", "ord",
+                "pow", "print", "range", "repr", "reversed", "round", "set",
+                "slice", "sorted", "str", "sum", "tuple", "type", "zip",
+            }
+            
+            self.globals["__builtins__"] = {
+                name: __builtins__[name] for name in allowed_builtins
+                if name in __builtins__
+            }
+        else:
+            self.globals["__builtins__"] = __builtins__
+    
+    def execute(self, code: str, globals_dict: Optional[Dict[str, Any]] = None) -> Any:
+        """Execute Python code in the sandbox"""
+        try:
+            # Validate syntax
+            ast.parse(code)
+            
+            # Merge globals
+            exec_globals = {**self.globals}
+            if globals_dict:
+                exec_globals.update(globals_dict)
+            
+            # Execute
+            exec(code, exec_globals, self.locals)
+            return self.locals
+        except SyntaxError as e:
+            raise RuntimeError(f"Syntax error in code: {e}")
+        except Exception as e:
+            raise RuntimeError(f"Runtime error: {e}")
+    
+    def execute_function(self, func: Callable, *args, **kwargs) -> Any:
+        """Execute a function with given arguments"""
+        try:
+            return func(*args, **kwargs)
+        except Exception as e:
+            raise RuntimeError(f"Function execution error: {e}")
+    
+    def load_module(self, module_path: str) -> Dict[str, Any]:
+        """Load and execute a Python module"""
+        path = Path(module_path)
+        
+        if not path.exists():
+            raise FileNotFoundError(f"Module not found: {module_path}")
+        
+        if not path.suffix == ".py":
+            raise ValueError(f"Invalid module file: {module_path}")
+        
+        with open(path, "r") as f:
+            code = f.read()
+        
+        return self.execute(code)
+
+
+class Render:
+    """Main entry point for rendering P2M applications"""
+    
+    _runtime: Optional[Runtime] = None
+    _component_tree: Optional[Any] = None
+    
+    @classmethod
+    def execute(cls, view_func: Callable, sandbox: bool = True) -> Any:
+        """Execute a view function and render the component tree"""
+        cls._runtime = Runtime(sandbox=sandbox)
+        
+        try:
+            # Call the view function
+            component_tree = cls._runtime.execute_function(view_func)
+            cls._component_tree = component_tree
+            return component_tree
+        except Exception as e:
+            raise RuntimeError(f"Failed to execute view: {e}")
+    
+    @classmethod
+    def get_component_tree(cls) -> Optional[Any]:
+        """Get the current component tree"""
+        return cls._component_tree
+    
+    @classmethod
+    def render_html(cls) -> str:
+        """Render component tree to HTML"""
+        from p2m.core.render_engine import RenderEngine
+        
+        if cls._component_tree is None:
+            raise RuntimeError("No component tree to render. Call execute() first.")
+        
+        engine = RenderEngine()
+        return engine.render(cls._component_tree)
+    
+    @classmethod
+    def render_json(cls) -> Dict[str, Any]:
+        """Render component tree to JSON (for mobile apps)"""
+        from p2m.core.ast_walker import ASTWalker
+        
+        if cls._component_tree is None:
+            raise RuntimeError("No component tree to render. Call execute() first.")
+        
+        walker = ASTWalker()
+        return walker.walk(cls._component_tree)

p2m/core/state.py

@@ -0,0 +1,51 @@
+"""
+P2M State Management - Simple state container for P2M apps
+"""
+from typing import Any, Dict
+
+
+class AppState:
+    """
+    Simple key-value state store.
+    Use module-level instances (singletons) so state is shared across files.
+
+    Example:
+        # state/store.py
+        from p2m.core.state import AppState
+        store = AppState(counter=0, todos=[])
+
+        # Any other file
+        from state.store import store
+        store.counter += 1
+    """
+
+    def __init__(self, **initial: Any):
+        # Use object.__setattr__ to avoid recursion in __setattr__
+        object.__setattr__(self, "_data", dict(initial))
+
+    def get(self, key: str, default: Any = None) -> Any:
+        return self._data.get(key, default)
+
+    def set(self, key: str, value: Any) -> None:
+        self._data[key] = value
+
+    def update(self, **kwargs: Any) -> None:
+        self._data.update(kwargs)
+
+    def __getattr__(self, key: str) -> Any:
+        data = object.__getattribute__(self, "_data")
+        if key in data:
+            return data[key]
+        raise AttributeError(f"AppState has no attribute '{key}'")
+
+    def __setattr__(self, key: str, value: Any) -> None:
+        self._data[key] = value
+
+    def __contains__(self, key: str) -> bool:
+        return key in self._data
+
+    def to_dict(self) -> Dict[str, Any]:
+        return dict(self._data)
+
+    def __repr__(self) -> str:
+        return f"AppState({self._data!r})"

p2m/core/validator.py

@@ -0,0 +1,284 @@
+"""
+P2M Code Validator - Validates P2M code for syntax and structure errors
+"""
+
+import ast
+import sys
+from typing import List, Tuple, Dict, Any
+from pathlib import Path
+
+
+class ValidationError:
+    """Represents a validation error"""
+    
+    def __init__(self, file: str, line: int, column: int, message: str, severity: str = "error"):
+        self.file = file
+        self.line = line
+        self.column = column
+        self.message = message
+        self.severity = severity  # "error", "warning", "info"
+    
+    def __str__(self) -> str:
+        return f"{self.file}:{self.line}:{self.column} [{self.severity.upper()}] {self.message}"
+    
+    def __repr__(self) -> str:
+        return self.__str__()
+
+
+class CodeValidator:
+    """Validates P2M code"""
+    
+    # Required imports for P2M apps
+    REQUIRED_IMPORTS = {
+        "Render": "from p2m.core import Render",
+        "Container": "from p2m.ui import Container",
+    }
+    
+    # Required functions
+    REQUIRED_FUNCTIONS = [
+        "create_view",
+        "main",
+    ]
+    
+    # Recommended patterns
+    RECOMMENDED_PATTERNS = {
+        "create_view_returns_build": "create_view should return component.build()",
+        "main_calls_render": "main should call Render.execute(create_view)",
+    }
+    
+    def __init__(self):
+        self.errors: List[ValidationError] = []
+        self.warnings: List[ValidationError] = []
+    
+    def validate_file(self, file_path: str) -> Tuple[bool, List[ValidationError], List[ValidationError]]:
+        """
+        Validate a single Python file
+        
+        Returns: (is_valid, errors, warnings)
+        """
+        self.errors = []
+        self.warnings = []
+        
+        try:
+            with open(file_path, 'r') as f:
+                content = f.read()
+            
+            # Check syntax
+            self._check_syntax(file_path, content)
+            
+            # Check imports
+            self._check_imports(file_path, content)
+            
+            # Check functions
+            self._check_functions(file_path, content)
+            
+            # Check patterns
+            self._check_patterns(file_path, content)
+            
+        except Exception as e:
+            self.errors.append(ValidationError(
+                file_path, 0, 0,
+                f"Failed to validate file: {str(e)}",
+                "error"
+            ))
+        
+        is_valid = len(self.errors) == 0
+        return is_valid, self.errors, self.warnings
+    
+    def validate_project(self, project_dir: str = ".", entry_file: str = "main.py") -> Tuple[bool, List[ValidationError], List[ValidationError]]:
+        """
+        Validate all Python files in a project.
+
+        The entry point file gets full validation (syntax + imports + functions + patterns).
+        All other module files get syntax-only validation.
+
+        Returns: (is_valid, all_errors, all_warnings)
+        """
+        all_errors = []
+        all_warnings = []
+
+        project_path = Path(project_dir)
+        entry_path = Path(entry_file)
+
+        # Find all Python files
+        py_files = list(project_path.glob("**/*.py"))
+
+        if not py_files:
+            all_errors.append(ValidationError(
+                project_dir, 0, 0,
+                "No Python files found in project",
+                "error"
+            ))
+            return False, all_errors, all_warnings
+
+        # Validate each file
+        for py_file in py_files:
+            # Skip __pycache__ and test files
+            if "__pycache__" in str(py_file) or py_file.name.startswith("test_"):
+                continue
+
+            # Check if this is the entry point file
+            is_entry = (py_file == entry_path or py_file.name == entry_path.name)
+
+            if is_entry:
+                # Full validation for entry point
+                is_valid, errors, warnings = self.validate_file(str(py_file))
+            else:
+                # Syntax-only validation for module files
+                is_valid, errors, warnings = self._validate_module(str(py_file))
+
+            all_errors.extend(errors)
+            all_warnings.extend(warnings)
+
+        is_valid = len(all_errors) == 0
+        return is_valid, all_errors, all_warnings
+
+    def _validate_module(self, file_path: str) -> Tuple[bool, List[ValidationError], List[ValidationError]]:
+        """
+        Validate a module file (syntax-only, no import/function/pattern checks).
+
+        Returns: (is_valid, errors, warnings)
+        """
+        errors = []
+        warnings = []
+
+        try:
+            with open(file_path, 'r') as f:
+                content = f.read()
+
+            # Only check syntax for module files
+            try:
+                ast.parse(content)
+            except SyntaxError as e:
+                errors.append(ValidationError(
+                    file_path, e.lineno or 0, e.offset or 0,
+                    f"Syntax error: {e.msg}",
+                    "error"
+                ))
+        except Exception as e:
+            errors.append(ValidationError(
+                file_path, 0, 0,
+                f"Failed to validate file: {str(e)}",
+                "error"
+            ))
+
+        is_valid = len(errors) == 0
+        return is_valid, errors, warnings
+    
+    def _check_syntax(self, file_path: str, content: str) -> None:
+        """Check Python syntax"""
+        try:
+            ast.parse(content)
+        except SyntaxError as e:
+            self.errors.append(ValidationError(
+                file_path, e.lineno or 0, e.offset or 0,
+                f"Syntax error: {e.msg}",
+                "error"
+            ))
+    
+    def _check_imports(self, file_path: str, content: str) -> None:
+        """Check for required imports"""
+        # Check for P2M imports
+        has_render_import = "from p2m.core import Render" in content or "from p2m import" in content
+        has_ui_import = "from p2m.ui import" in content
+        
+        if not has_render_import:
+            self.warnings.append(ValidationError(
+                file_path, 1, 0,
+                "Missing P2M core import (from p2m.core import Render)",
+                "warning"
+            ))
+        
+        if not has_ui_import:
+            self.warnings.append(ValidationError(
+                file_path, 1, 0,
+                "Missing P2M UI imports (from p2m.ui import ...)",
+                "warning"
+            ))
+    
+    def _check_functions(self, file_path: str, content: str) -> None:
+        """Check for required functions"""
+        try:
+            tree = ast.parse(content)
+            
+            functions = {node.name for node in ast.walk(tree) if isinstance(node, ast.FunctionDef)}
+            
+            for required_func in self.REQUIRED_FUNCTIONS:
+                if required_func not in functions:
+                    self.errors.append(ValidationError(
+                        file_path, 0, 0,
+                        f"Missing required function: {required_func}()",
+                        "error"
+                    ))
+        except:
+            pass  # Already reported in syntax check
+    
+    def _check_patterns(self, file_path: str, content: str) -> None:
+        """Check for recommended patterns"""
+        
+        # Check if create_view returns .build()
+        if "def create_view" in content:
+            # Look for .build() in the file
+            if ".build()" not in content:
+                self.warnings.append(ValidationError(
+                    file_path, 0, 0,
+                    "create_view should return component.build()",
+                    "warning"
+                ))
+        
+        # Check if main calls Render.execute
+        if "def main" in content:
+            if "Render.execute" not in content:
+                self.warnings.append(ValidationError(
+                    file_path, 0, 0,
+                    "main should call Render.execute(create_view)",
+                    "warning"
+                ))
+    
+    def print_report(self, is_valid: bool, errors: List[ValidationError], warnings: List[ValidationError]) -> None:
+        """Print validation report"""
+        
+        print("\n" + "="*70)
+        print("📋 Code Validation Report")
+        print("="*70)
+        
+        if errors:
+            print(f"\n❌ Errors ({len(errors)}):")
+            for error in errors:
+                print(f"   {error}")
+        
+        if warnings:
+            print(f"\n⚠️  Warnings ({len(warnings)}):")
+            for warning in warnings:
+                print(f"   {warning}")
+        
+        if is_valid and not warnings:
+            print("\n✅ All validations passed!")
+        elif is_valid:
+            print(f"\n✅ Code is valid ({len(warnings)} warning(s))")
+        else:
+            print(f"\n❌ Validation failed ({len(errors)} error(s))")
+        
+        print("="*70 + "\n")
+    
+    def get_summary(self, is_valid: bool, errors: List[ValidationError], warnings: List[ValidationError]) -> str:
+        """Get a summary of validation results"""
+        
+        if not is_valid:
+            return f"❌ Validation failed: {len(errors)} error(s), {len(warnings)} warning(s)"
+        elif warnings:
+            return f"⚠️  Validation passed with {len(warnings)} warning(s)"
+        else:
+            return "✅ Validation passed"
+
+
+def validate_project(project_dir: str = ".", entry_file: str = "main.py") -> Tuple[bool, List[ValidationError], List[ValidationError]]:
+    """Validate a P2M project"""
+    validator = CodeValidator()
+    return validator.validate_project(project_dir, entry_file=entry_file)
+
+
+def validate_file(file_path: str) -> Tuple[bool, List[ValidationError], List[ValidationError]]:
+    """Validate a single P2M file"""
+    validator = CodeValidator()
+    return validator.validate_file(file_path)

p2m/devserver/__init__.py

@@ -0,0 +1,9 @@
+"""
+P2M DevServer - Development server with hot reload
+"""
+
+from p2m.devserver.server import start_server
+
+__all__ = [
+    "start_server",
+]

p2m/devserver/server.py

@@ -0,0 +1,84 @@
+"""
+P2M DevServer - FastAPI + WebSocket live reload and event bridge.
+
+Flow:
+  Browser click → WS → dispatch(action) → handler updates state
+  → Render.execute(view_func) → render_content() → WS → browser innerHTML swap
+"""
+import json
+from typing import Callable, Optional
+
+from fastapi import FastAPI, WebSocket, WebSocketDisconnect
+from fastapi.responses import HTMLResponse
+
+
+def start_server(
+    html_content: str,
+    port: int = 3000,
+    view_func: Optional[Callable] = None,
+    project_dir: str = ".",
+):
+    from p2m.core import events
+    from p2m.core.render_engine import RenderEngine
+    from p2m.core.runtime import Render
+    from fastapi.staticfiles import StaticFiles
+    from pathlib import Path
+
+    app = FastAPI()
+    app.state.html_content = html_content
+    app.state.view_func = view_func
+
+    assets_path = Path(project_dir) / "assets"
+    if assets_path.is_dir():
+        app.mount("/assets", StaticFiles(directory=str(assets_path)), name="assets")
+
+    @app.get("/", response_class=HTMLResponse)
+    async def root():
+        return app.state.html_content
+
+    @app.websocket("/ws")
+    async def ws_endpoint(websocket: WebSocket):
+        await websocket.accept()
+        try:
+            while True:
+                raw = await websocket.receive_text()
+                try:
+                    data = json.loads(raw)
+                    etype = data.get("type", "")
+                    action = data.get("action", "")
+
+                    if etype == "click":
+                        args = data.get("args", [])
+                        events.dispatch(action, *args)
+                    elif etype in ("change", "input"):
+                        value = data.get("value", "")
+                        events.dispatch(action, value)
+
+                    # Re-render and push new content
+                    if app.state.view_func:
+                        tree = Render.execute(app.state.view_func)
+                        engine = RenderEngine()
+                        content = engine.render_content(tree)
+                        await websocket.send_text(
+                            json.dumps({"type": "render", "html": content})
+                        )
+
+                except json.JSONDecodeError:
+                    pass
+                except Exception as exc:
+                    import traceback
+                    traceback.print_exc()
+                    try:
+                        await websocket.send_text(
+                            json.dumps({"type": "error", "message": str(exc)})
+                        )
+                    except Exception:
+                        pass
+
+        except WebSocketDisconnect:
+            pass
+        except Exception as exc:
+            print(f"[P2M] WebSocket fatal: {exc}")
+
+    import uvicorn
+    uvicorn.run(app, host="0.0.0.0", port=port, log_level="warning")

p2m/i18n/__init__.py

@@ -0,0 +1,7 @@
+"""
+P2M i18n — Internationalisation helpers.
+"""
+
+from p2m.i18n.translator import configure, set_locale, get_locale, t
+
+__all__ = ["configure", "set_locale", "get_locale", "t"]

p2m/i18n/translator.py

@@ -0,0 +1,74 @@
+"""
+P2M i18n — Simple JSON-based translator.
+
+Usage:
+    from p2m.i18n import configure, set_locale, get_locale, t
+
+    configure("locales/", default_locale="pt")
+    t("search_placeholder")          # "Buscar restaurantes..."
+    t("greeting", name="João")       # "Olá, João!"
+    set_locale("en")
+    t("search_placeholder")          # "Search restaurants..."
+"""
+
+import json
+from pathlib import Path
+from typing import Any, Dict, Optional
+
+_locale: str = "en"
+_translations: Dict[str, Dict[str, str]] = {}
+_locales_dir: Optional[Path] = None
+
+
+def configure(locales_dir: str, default_locale: str = "en") -> None:
+    """Point to the locales directory and set the default locale."""
+    global _locales_dir, _locale, _translations
+    _locales_dir = Path(locales_dir)
+    _translations = {}
+    _locale = default_locale
+    _load_locale(default_locale)
+
+
+def set_locale(locale: str) -> None:
+    """Switch to a different locale (loads JSON if not yet cached)."""
+    global _locale
+    _locale = locale
+    _load_locale(locale)
+
+
+def get_locale() -> str:
+    """Return the currently active locale code."""
+    return _locale
+
+
+def t(key: str, **kwargs: Any) -> str:
+    """Look up *key* in the current locale's translations.
+
+    Falls back to the key string itself if the key is missing.
+    Supports keyword formatting: t("greeting", name="João") with
+    {"greeting": "Olá, {name}!"} → "Olá, João!"
+    """
+    locale_dict = _translations.get(_locale, {})
+    template = locale_dict.get(key, key)
+    if kwargs:
+        try:
+            return template.format(**kwargs)
+        except (KeyError, ValueError):
+            return template
+    return template
+
+
+# ── Internal ──────────────────────────────────────────────────────────────────
+
+def _load_locale(locale: str) -> None:
+    if locale in _translations:
+        return
+    if _locales_dir is None:
+        _translations[locale] = {}
+        return
+    json_path = _locales_dir / f"{locale}.json"
+    if json_path.is_file():
+        with open(json_path, encoding="utf-8") as fh:
+            _translations[locale] = json.load(fh)
+    else:
+        _translations[locale] = {}

p2m/imagine/__init__.py

@@ -0,0 +1,35 @@
+"""
+P2M Imagine — Generate complete multi-file P2M projects from natural language.
+
+Two modes:
+- Agent mode (default): uses Agno + LLM to create full project structure
+- Legacy mode (--no-agent): generates a single Python file via direct LLM call
+"""
+
+import os
+from typing import Optional
+
+
+def agent_available(provider: str = "openai", api_key: Optional[str] = None) -> bool:
+    """
+    Return True when agent-based generation is possible.
+
+    Requires:
+    - `agno` installed
+    - A valid API key (argument, env var, or config)
+    """
+    try:
+        import agno  # noqa: F401
+    except ImportError:
+        return False
+
+    if provider.lower() == "anthropic":
+        return bool(api_key or os.environ.get("ANTHROPIC_API_KEY"))
+    # openai / openai-compatible / default
+    return bool(api_key or os.environ.get("OPENAI_API_KEY"))
+
+
+from p2m.imagine.legacy import imagine_command  # noqa: E402
+from p2m.imagine.agent import run_imagine_agent  # noqa: E402
+
+__all__ = ["imagine_command", "run_imagine_agent", "agent_available"]