python2mobile 1.0.1__py3-none-any.whl

p2m/core/api.py

@@ -0,0 +1,191 @@
+"""
+P2M API Client - HTTP request handling for P2M applications
+Supports GET, POST, PUT, DELETE requests with proper error handling
+"""
+
+import json
+from typing import Dict, Any, Optional, Callable
+from enum import Enum
+
+
+class HTTPMethod(Enum):
+    """HTTP methods"""
+    GET = "GET"
+    POST = "POST"
+    PUT = "PUT"
+    DELETE = "DELETE"
+    PATCH = "PATCH"
+
+
+class APIResponse:
+    """Represents an API response"""
+    
+    def __init__(self, status_code: int, data: Any, error: Optional[str] = None):
+        self.status_code = status_code
+        self.data = data
+        self.error = error
+        self.success = 200 <= status_code < 300
+    
+    def json(self) -> Dict[str, Any]:
+        """Get response as JSON"""
+        if isinstance(self.data, dict):
+            return self.data
+        try:
+            return json.loads(self.data) if isinstance(self.data, str) else self.data
+        except:
+            return {"error": "Invalid JSON"}
+    
+    def __repr__(self) -> str:
+        return f"APIResponse(status={self.status_code}, success={self.success})"
+
+
+class APIClient:
+    """HTTP client for making API requests"""
+    
+    def __init__(self, base_url: str = "", default_headers: Optional[Dict[str, str]] = None):
+        """
+        Initialize API client
+        
+        Args:
+            base_url: Base URL for all requests
+            default_headers: Default headers to include in all requests
+        """
+        self.base_url = base_url.rstrip('/')
+        self.default_headers = default_headers or {}
+        self.timeout = 30
+    
+    def _build_url(self, endpoint: str) -> str:
+        """Build full URL from endpoint"""
+        if endpoint.startswith('http'):
+            return endpoint
+        return f"{self.base_url}/{endpoint.lstrip('/')}" if self.base_url else endpoint
+    
+    def _merge_headers(self, headers: Optional[Dict[str, str]]) -> Dict[str, str]:
+        """Merge default headers with request-specific headers"""
+        merged = self.default_headers.copy()
+        if headers:
+            merged.update(headers)
+        return merged
+    
+    async def get(
+        self,
+        endpoint: str,
+        params: Optional[Dict[str, Any]] = None,
+        headers: Optional[Dict[str, str]] = None
+    ) -> APIResponse:
+        """
+        Make a GET request
+        
+        Args:
+            endpoint: API endpoint
+            params: Query parameters
+            headers: Request headers
+        
+        Returns:
+            APIResponse object
+        """
+        url = self._build_url(endpoint)
+        headers = self._merge_headers(headers)
+        
+        try:
+            # This will be implemented differently on each platform
+            # For now, return a placeholder
+            return APIResponse(200, {"message": "GET request to " + url})
+        except Exception as e:
+            return APIResponse(500, None, str(e))
+    
+    async def post(
+        self,
+        endpoint: str,
+        data: Optional[Dict[str, Any]] = None,
+        headers: Optional[Dict[str, str]] = None
+    ) -> APIResponse:
+        """
+        Make a POST request
+        
+        Args:
+            endpoint: API endpoint
+            data: Request body
+            headers: Request headers
+        
+        Returns:
+            APIResponse object
+        """
+        url = self._build_url(endpoint)
+        headers = self._merge_headers(headers)
+        headers['Content-Type'] = 'application/json'
+        
+        try:
+            # This will be implemented differently on each platform
+            # For now, return a placeholder
+            return APIResponse(201, {"message": "POST request to " + url})
+        except Exception as e:
+            return APIResponse(500, None, str(e))
+    
+    async def put(
+        self,
+        endpoint: str,
+        data: Optional[Dict[str, Any]] = None,
+        headers: Optional[Dict[str, str]] = None
+    ) -> APIResponse:
+        """
+        Make a PUT request
+        
+        Args:
+            endpoint: API endpoint
+            data: Request body
+            headers: Request headers
+        
+        Returns:
+            APIResponse object
+        """
+        url = self._build_url(endpoint)
+        headers = self._merge_headers(headers)
+        headers['Content-Type'] = 'application/json'
+        
+        try:
+            return APIResponse(200, {"message": "PUT request to " + url})
+        except Exception as e:
+            return APIResponse(500, None, str(e))
+    
+    async def delete(
+        self,
+        endpoint: str,
+        headers: Optional[Dict[str, str]] = None
+    ) -> APIResponse:
+        """
+        Make a DELETE request
+        
+        Args:
+            endpoint: API endpoint
+            headers: Request headers
+        
+        Returns:
+            APIResponse object
+        """
+        url = self._build_url(endpoint)
+        headers = self._merge_headers(headers)
+        
+        try:
+            return APIResponse(204, None)
+        except Exception as e:
+            return APIResponse(500, None, str(e))
+
+
+# Global API client instance
+_api_client: Optional[APIClient] = None
+
+
+def init_api(base_url: str = "", default_headers: Optional[Dict[str, str]] = None) -> APIClient:
+    """Initialize global API client"""
+    global _api_client
+    _api_client = APIClient(base_url, default_headers)
+    return _api_client
+
+
+def get_api() -> APIClient:
+    """Get global API client"""
+    global _api_client
+    if _api_client is None:
+        _api_client = APIClient()
+    return _api_client

p2m/core/ast_walker.py

@@ -0,0 +1,171 @@
+"""
+P2M AST Walker - Analyzes component tree structure
+"""
+
+import ast
+from typing import Any, Dict, List, Optional
+
+
+class ASTWalker:
+    """Walks and analyzes component tree"""
+    
+    def __init__(self):
+        self.components: List[Dict[str, Any]] = []
+        self.handlers: Dict[str, Any] = {}
+    
+    def walk(self, component_tree: Dict[str, Any]) -> Dict[str, Any]:
+        """Walk component tree and extract structure"""
+        self.components = []
+        self.handlers = {}
+        
+        self._walk_component(component_tree)
+        
+        return {
+            "components": self.components,
+            "handlers": self.handlers,
+        }
+    
+    def _walk_component(self, component: Dict[str, Any], parent_id: str = "root") -> None:
+        """Recursively walk component tree"""
+        component_type = component.get("type", "unknown")
+        props = component.get("props", {})
+        children = component.get("children", [])
+        
+        # Extract component info
+        component_info = {
+            "type": component_type,
+            "props": props,
+            "children_count": len(children),
+        }
+        
+        self.components.append(component_info)
+        
+        # Extract handlers
+        for key, value in props.items():
+            if key.startswith("on_") and value:
+                handler_name = value
+                self.handlers[handler_name] = {
+                    "component": component_type,
+                    "event": key,
+                }
+        
+        # Walk children
+        for child in children:
+            if isinstance(child, dict):
+                self._walk_component(child, parent_id)
+    
+    def extract_handlers(self, component_tree: Dict[str, Any]) -> Dict[str, Any]:
+        """Extract all event handlers from component tree"""
+        handlers = {}
+        self._extract_handlers_recursive(component_tree, handlers)
+        return handlers
+    
+    def _extract_handlers_recursive(self, component: Dict[str, Any], 
+                                   handlers: Dict[str, Any]) -> None:
+        """Recursively extract handlers"""
+        props = component.get("props", {})
+        
+        for key, value in props.items():
+            if key.startswith("on_") and value:
+                handlers[value] = {
+                    "component": component.get("type"),
+                    "event": key,
+                }
+        
+        children = component.get("children", [])
+        for child in children:
+            if isinstance(child, dict):
+                self._extract_handlers_recursive(child, handlers)
+    
+    def analyze_structure(self, component_tree: Dict[str, Any]) -> Dict[str, Any]:
+        """Analyze component tree structure"""
+        analysis = {
+            "total_components": 0,
+            "component_types": {},
+            "depth": 0,
+            "handlers": {},
+        }
+        
+        self._analyze_recursive(component_tree, analysis, 0)
+        return analysis
+    
+    def _analyze_recursive(self, component: Dict[str, Any], 
+                          analysis: Dict[str, Any], depth: int) -> None:
+        """Recursively analyze structure"""
+        component_type = component.get("type", "unknown")
+        
+        # Update counts
+        analysis["total_components"] += 1
+        analysis["component_types"][component_type] = analysis["component_types"].get(component_type, 0) + 1
+        analysis["depth"] = max(analysis["depth"], depth)
+        
+        # Extract handlers
+        props = component.get("props", {})
+        for key, value in props.items():
+            if key.startswith("on_") and value:
+                analysis["handlers"][value] = {
+                    "component": component_type,
+                    "event": key,
+                }
+        
+        # Analyze children
+        children = component.get("children", [])
+        for child in children:
+            if isinstance(child, dict):
+                self._analyze_recursive(child, analysis, depth + 1)
+
+
+class CodeExtractor:
+    """Extracts Python code information for LLM"""
+    
+    def __init__(self, file_path: str):
+        self.file_path = file_path
+        self.tree: Optional[ast.AST] = None
+        self.functions: Dict[str, str] = {}
+        self.imports: List[str] = []
+        self.classes: Dict[str, str] = {}
+    
+    def extract(self) -> Dict[str, Any]:
+        """Extract code information"""
+        with open(self.file_path, "r") as f:
+            code = f.read()
+        
+        self.tree = ast.parse(code)
+        self._extract_imports()
+        self._extract_functions()
+        self._extract_classes()
+        
+        return {
+            "file": self.file_path,
+            "imports": self.imports,
+            "functions": self.functions,
+            "classes": self.classes,
+            "raw_code": code,
+        }
+    
+    def _extract_imports(self) -> None:
+        """Extract import statements"""
+        for node in ast.walk(self.tree):
+            if isinstance(node, ast.Import):
+                for alias in node.names:
+                    self.imports.append(alias.name)
+            elif isinstance(node, ast.ImportFrom):
+                module = node.module or ""
+                for alias in node.names:
+                    self.imports.append(f"from {module} import {alias.name}")
+    
+    def _extract_functions(self) -> None:
+        """Extract function definitions"""
+        for node in ast.walk(self.tree):
+            if isinstance(node, ast.FunctionDef):
+                self.functions[node.name] = ast.get_source_segment(
+                    open(self.file_path).read(), node
+                ) or ""
+    
+    def _extract_classes(self) -> None:
+        """Extract class definitions"""
+        for node in ast.walk(self.tree):
+            if isinstance(node, ast.ClassDef):
+                self.classes[node.name] = ast.get_source_segment(
+                    open(self.file_path).read(), node
+                ) or ""

p2m/core/database.py

@@ -0,0 +1,192 @@
+"""
+P2M Local Database - Persistent storage for P2M applications
+Supports key-value storage with JSON serialization
+"""
+
+import json
+from typing import Dict, Any, Optional, List, Union
+from abc import ABC, abstractmethod
+
+
+class Database(ABC):
+    """Abstract base class for database implementations"""
+    
+    @abstractmethod
+    async def set(self, key: str, value: Any) -> bool:
+        """Set a value in the database"""
+        pass
+    
+    @abstractmethod
+    async def get(self, key: str, default: Any = None) -> Any:
+        """Get a value from the database"""
+        pass
+    
+    @abstractmethod
+    async def delete(self, key: str) -> bool:
+        """Delete a value from the database"""
+        pass
+    
+    @abstractmethod
+    async def clear(self) -> bool:
+        """Clear all data from the database"""
+        pass
+    
+    @abstractmethod
+    async def keys(self) -> List[str]:
+        """Get all keys in the database"""
+        pass
+    
+    @abstractmethod
+    async def has(self, key: str) -> bool:
+        """Check if a key exists in the database"""
+        pass
+
+
+class LocalDatabase(Database):
+    """In-memory database implementation (for testing)"""
+    
+    def __init__(self):
+        self._data: Dict[str, Any] = {}
+    
+    async def set(self, key: str, value: Any) -> bool:
+        """Set a value in the database"""
+        try:
+            # Serialize to JSON to ensure compatibility
+            if isinstance(value, (dict, list)):
+                self._data[key] = json.dumps(value)
+            else:
+                self._data[key] = str(value)
+            return True
+        except Exception as e:
+            print(f"Error setting key {key}: {e}")
+            return False
+    
+    async def get(self, key: str, default: Any = None) -> Any:
+        """Get a value from the database"""
+        try:
+            value = self._data.get(key, default)
+            if value is None:
+                return default
+            
+            # Try to deserialize JSON
+            try:
+                return json.loads(value)
+            except:
+                return value
+        except Exception as e:
+            print(f"Error getting key {key}: {e}")
+            return default
+    
+    async def delete(self, key: str) -> bool:
+        """Delete a value from the database"""
+        try:
+            if key in self._data:
+                del self._data[key]
+                return True
+            return False
+        except Exception as e:
+            print(f"Error deleting key {key}: {e}")
+            return False
+    
+    async def clear(self) -> bool:
+        """Clear all data from the database"""
+        try:
+            self._data.clear()
+            return True
+        except Exception as e:
+            print(f"Error clearing database: {e}")
+            return False
+    
+    async def keys(self) -> List[str]:
+        """Get all keys in the database"""
+        return list(self._data.keys())
+    
+    async def has(self, key: str) -> bool:
+        """Check if a key exists in the database"""
+        return key in self._data
+
+
+class Table:
+    """Represents a table in the database"""
+    
+    def __init__(self, name: str, db: Database):
+        self.name = name
+        self.db = db
+    
+    def _make_key(self, item_id: Union[str, int]) -> str:
+        """Create a table-scoped key"""
+        return f"{self.name}:{item_id}"
+    
+    async def insert(self, item_id: Union[str, int], data: Dict[str, Any]) -> bool:
+        """Insert an item into the table"""
+        key = self._make_key(item_id)
+        return await self.db.set(key, data)
+    
+    async def get(self, item_id: Union[str, int], default: Any = None) -> Any:
+        """Get an item from the table"""
+        key = self._make_key(item_id)
+        return await self.db.get(key, default)
+    
+    async def update(self, item_id: Union[str, int], data: Dict[str, Any]) -> bool:
+        """Update an item in the table"""
+        key = self._make_key(item_id)
+        existing = await self.db.get(key, {})
+        
+        if isinstance(existing, dict):
+            existing.update(data)
+            return await self.db.set(key, existing)
+        
+        return await self.db.set(key, data)
+    
+    async def delete(self, item_id: Union[str, int]) -> bool:
+        """Delete an item from the table"""
+        key = self._make_key(item_id)
+        return await self.db.delete(key)
+    
+    async def all(self) -> List[Dict[str, Any]]:
+        """Get all items from the table"""
+        items = []
+        all_keys = await self.db.keys()
+        
+        for key in all_keys:
+            if key.startswith(f"{self.name}:"):
+                item = await self.db.get(key)
+                if isinstance(item, dict):
+                    items.append(item)
+        
+        return items
+    
+    async def clear(self) -> bool:
+        """Clear all items from the table"""
+        all_keys = await self.db.keys()
+        
+        for key in all_keys:
+            if key.startswith(f"{self.name}:"):
+                await self.db.delete(key)
+        
+        return True
+
+
+# Global database instance
+_database: Optional[Database] = None
+
+
+def init_database(db: Optional[Database] = None) -> Database:
+    """Initialize global database"""
+    global _database
+    _database = db or LocalDatabase()
+    return _database
+
+
+def get_database() -> Database:
+    """Get global database"""
+    global _database
+    if _database is None:
+        _database = LocalDatabase()
+    return _database
+
+
+def get_table(name: str) -> Table:
+    """Get a table from the global database"""
+    db = get_database()
+    return Table(name, db)

p2m/core/events.py

@@ -0,0 +1,56 @@
+"""
+P2M Event System - Global handler registry
+Handlers are registered by name and dispatched on WebSocket events.
+"""
+from typing import Any, Callable, Dict
+
+
+_handlers: Dict[str, Callable] = {}
+
+
+def register(name: str, func: Callable) -> None:
+    """Register a named event handler."""
+    _handlers[name] = func
+
+
+def unregister(name: str) -> None:
+    _handlers.pop(name, None)
+
+
+def clear() -> None:
+    _handlers.clear()
+
+
+def dispatch(name: str, *args: Any) -> bool:
+    """Call handler by name. Returns True if handler found."""
+    handler = _handlers.get(name)
+    if not handler:
+        return False
+    try:
+        if args:
+            handler(*args)
+        else:
+            handler()
+        return True
+    except TypeError:
+        # Handler signature mismatch — try without args
+        try:
+            handler()
+            return True
+        except Exception as e:
+            print(f"[P2M] Handler '{name}' error: {e}")
+    except Exception as e:
+        print(f"[P2M] Handler '{name}' error: {e}")
+    return False
+
+
+def on(name: str) -> Callable:
+    """Decorator: @events.on('my_action')"""
+    def decorator(func: Callable) -> Callable:
+        _handlers[name] = func
+        return func
+    return decorator
+
+
+def has(name: str) -> bool:
+    return name in _handlers