pythonnative 0.35.0__py3-none-any.whl → 0.37.0__py3-none-any.whl

pythonnative/native_modules/clipboard.py

@@ -1,13 +1,11 @@
 """Cross-platform clipboard access.
 
 [`Clipboard`][pythonnative.Clipboard] reads and writes the system
-pasteboard. All methods are synchronous: ``UIPasteboard`` (iOS) and
-``ClipboardManager`` (Android) both answer immediately, so there's no
-need for a coroutine.
+pasteboard through the native ``Clipboard`` module (``UIPasteboard``
+on iOS, ``ClipboardManager`` on Android). All methods are synchronous.
 
-On a desktop machine (neither Android nor iOS) the module falls back to
-a process-local string buffer. That keeps it usable in the desktop
-mock target and unit tests instead of raising.
+Off device the module is a process-local string buffer, which keeps it
+usable in ``pn preview`` and unit tests.
 
 Example:
     ```python
@@ -20,13 +18,8 @@ Example:
 
 from __future__ import annotations
 
-from typing import Optional
-
 from .. import diagnostics
-from ..utils import IS_ANDROID, IS_IOS
-
-# Desktop fallback buffer so the API is usable off-device.
-_desktop_buffer: str = ""
+from .registry import native_module
 
 
 class Clipboard:
@@ -35,109 +28,21 @@ class Clipboard:
     @staticmethod
     def set_string(text: str) -> None:
         """Copy ``text`` onto the system clipboard."""
-        global _desktop_buffer
-        value = "" if text is None else str(text)
-        if IS_ANDROID:
-            _android_set(value)
-        elif IS_IOS:
-            _ios_set(value)
-        else:
-            _desktop_buffer = value
+        try:
+            native_module("Clipboard").call("set_string", text="" if text is None else str(text))
+        except Exception:
+            diagnostics.swallowed("clipboard.set_string")
 
     @staticmethod
     def get_string() -> str:
         """Return the current clipboard string (``""`` when empty)."""
-        if IS_ANDROID:
-            return _android_get()
-        if IS_IOS:
-            return _ios_get()
-        return _desktop_buffer
+        try:
+            value = native_module("Clipboard").call("get_string")
+        except Exception:
+            return ""
+        return "" if value is None else str(value)
 
     @staticmethod
     def has_string() -> bool:
         """Return ``True`` when the clipboard holds non-empty text."""
         return bool(Clipboard.get_string())
-
-
-# ======================================================================
-# iOS: UIPasteboard
-# ======================================================================
-
-
-def _ios_pasteboard() -> Optional[object]:
-    try:
-        from rubicon.objc import ObjCClass
-
-        return ObjCClass("UIPasteboard").generalPasteboard
-    except Exception:
-        return None
-
-
-def _ios_set(text: str) -> None:
-    pb = _ios_pasteboard()
-    if pb is None:
-        return
-    try:
-        pb.string = text
-    except Exception:
-        diagnostics.swallowed("clipboard._ios_set")
-
-
-def _ios_get() -> str:
-    pb = _ios_pasteboard()
-    if pb is None:
-        return ""
-    try:
-        value = pb.string
-        return str(value) if value is not None else ""
-    except Exception:
-        return ""
-
-
-# ======================================================================
-# Android: ClipboardManager
-# ======================================================================
-
-
-def _android_manager() -> Optional[object]:
-    try:
-        from java import jclass
-
-        from ..utils import get_android_context
-
-        ctx = get_android_context()
-        Context = jclass("android.content.Context")
-        return ctx.getSystemService(Context.CLIPBOARD_SERVICE)
-    except Exception:
-        return None
-
-
-def _android_set(text: str) -> None:
-    manager = _android_manager()
-    if manager is None:
-        return
-    try:
-        from java import jclass
-
-        ClipData = jclass("android.content.ClipData")
-        clip = ClipData.newPlainText("pythonnative", text)
-        manager.setPrimaryClip(clip)
-    except Exception:
-        diagnostics.swallowed("clipboard._android_set")
-
-
-def _android_get() -> str:
-    manager = _android_manager()
-    if manager is None:
-        return ""
-    try:
-        if not manager.hasPrimaryClip():
-            return ""
-        clip = manager.getPrimaryClip()
-        if clip is None or clip.getItemCount() == 0:
-            return ""
-        item = clip.getItemAt(0)
-        text = item.getText()
-        return str(text) if text is not None else ""
-    except Exception:
-        return ""

pythonnative/native_modules/desktop.py

@@ -0,0 +1,322 @@
+"""Off-device implementations of the built-in native modules.
+
+On iOS and Android every module in this package is implemented in
+Swift and Kotlin (``PythonNativeKit`` and the ``pythonnative`` Gradle
+module). Off device (``pn preview``, unit tests) the same module names
+resolve to the plain Python classes below, which keep the API usable
+without a device: in-memory buffers, ``"unknown"`` states, and no-op
+feedback.
+
+Each class has the same method names and argument shapes as its native
+counterpart, so a facade in this package never branches on platform.
+Apps and tests may swap any of these with
+[`register_python_module`][pythonnative.native_modules.registry.register_python_module].
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import platform as _platform
+import sys
+import threading
+from typing import Any, Callable, Dict, List, Optional
+
+__all__ = ["default_implementation"]
+
+
+# ======================================================================
+# Device / host information
+# ======================================================================
+
+
+class DesktopDevice:
+    """Static device information for the desktop preview."""
+
+    def info(self) -> Dict[str, Any]:
+        home = os.path.expanduser("~")
+        app_dir = os.path.join(home, ".pythonnative_data")
+        return {
+            "platform": "desktop",
+            "os": sys.platform,
+            "os_version": _platform.release(),
+            "model": _platform.machine(),
+            "app_dir": app_dir,
+            "cache_dir": os.path.join(app_dir, "cache"),
+            "temp_dir": os.path.join(app_dir, "tmp"),
+            "locale": os.environ.get("LANG", "en_US").split(".")[0],
+            "app_version": "0.0.0",
+            "build_number": "0",
+            "bundle_id": "com.pythonnative.preview",
+            "python_version": _platform.python_version(),
+        }
+
+
+class DesktopAppState:
+    def current_state(self) -> str:
+        return "active"
+
+
+# ======================================================================
+# Storage
+# ======================================================================
+
+
+class DesktopStorage:
+    """Dict-backed ``AsyncStorage`` with optional JSON persistence.
+
+    Set ``PN_STORAGE_DIR`` to persist between runs (``pn preview`` does
+    this); leave it unset in tests for a purely in-memory store.
+    """
+
+    def __init__(self) -> None:
+        self._lock = threading.Lock()
+        self._store: Dict[str, str] = {}
+        self._loaded = False
+
+    def _path(self) -> Optional[str]:
+        base = os.environ.get("PN_STORAGE_DIR")
+        if not base:
+            return None
+        try:
+            os.makedirs(base, exist_ok=True)
+        except OSError:
+            return None
+        return os.path.join(base, "pn_async_storage.json")
+
+    def _load(self) -> None:
+        if self._loaded:
+            return
+        self._loaded = True
+        path = self._path()
+        if path is None or not os.path.exists(path):
+            return
+        try:
+            with open(path, encoding="utf-8") as f:
+                data = json.load(f)
+        except (OSError, json.JSONDecodeError):
+            return
+        if isinstance(data, dict):
+            self._store.update({str(k): str(v) for k, v in data.items()})
+
+    def _persist(self) -> None:
+        path = self._path()
+        if path is None:
+            return
+        try:
+            with open(path, "w", encoding="utf-8") as f:
+                json.dump(self._store, f)
+        except OSError:
+            pass
+
+    def get(self, key: str) -> Optional[str]:
+        with self._lock:
+            self._load()
+            return self._store.get(key)
+
+    def set(self, key: str, value: str) -> None:
+        with self._lock:
+            self._load()
+            self._store[key] = value
+            self._persist()
+
+    def delete(self, key: str) -> None:
+        with self._lock:
+            self._load()
+            self._store.pop(key, None)
+            self._persist()
+
+    def all_keys(self) -> List[str]:
+        with self._lock:
+            self._load()
+            return list(self._store.keys())
+
+    def clear(self) -> None:
+        with self._lock:
+            self._store.clear()
+            self._persist()
+
+    def _reset(self) -> None:
+        """Forget everything, including the on-disk snapshot (tests)."""
+        with self._lock:
+            self._store.clear()
+            self._loaded = False
+
+
+class DesktopSecureStore:
+    def __init__(self) -> None:
+        self._store: Dict[str, str] = {}
+
+    def set_item(self, key: str, value: str) -> bool:
+        self._store[key] = value
+        return True
+
+    def get_item(self, key: str) -> Optional[str]:
+        return self._store.get(key)
+
+    def delete_item(self, key: str) -> bool:
+        return self._store.pop(key, None) is not None
+
+    def clear(self) -> None:
+        self._store.clear()
+
+
+class DesktopClipboard:
+    def __init__(self) -> None:
+        self._buffer = ""
+
+    def set_string(self, text: str) -> None:
+        self._buffer = "" if text is None else str(text)
+
+    def get_string(self) -> str:
+        return self._buffer
+
+
+# ======================================================================
+# System integration
+# ======================================================================
+
+
+class DesktopAlert:
+    """Records alerts and answers with scripted responses.
+
+    The log and response queue live on
+    [`Alert`][pythonnative.alerts.Alert] (``Alert._test_log`` and
+    ``Alert.set_test_response``) so tests have one place to look.
+    """
+
+    @staticmethod
+    def _record(title: str, message: Optional[str], buttons: List[Dict[str, Any]], style: str) -> Any:
+        from ..alerts import Alert
+
+        Alert._test_log.append({"title": title, "message": message, "buttons": list(buttons), "style": style})
+        return Alert
+
+    def show(self, title: str, message: Optional[str], buttons: List[Dict[str, Any]], style: str) -> None:
+        self._record(title, message, buttons, style)
+
+    def present(self, title: str, message: Optional[str], buttons: List[Dict[str, Any]], style: str) -> int:
+        return int(self._record(title, message, buttons, style)._next_test_response())
+
+
+class DesktopShare:
+    def share(self, message: Optional[str] = None, url: Optional[str] = None, title: Optional[str] = None) -> bool:
+        del message, url, title
+        return False
+
+
+class DesktopLinking:
+    def open_url(self, url: str) -> bool:
+        del url
+        return False
+
+    def can_open_url(self, url: str) -> bool:
+        del url
+        return False
+
+    def open_settings(self) -> bool:
+        return False
+
+
+class DesktopHaptics:
+    def impact(self, style: str = "medium") -> None:
+        del style
+
+    def notification(self, type: str = "success") -> None:  # noqa: A002 - wire name
+        del type
+
+    def selection(self) -> None:
+        pass
+
+    def vibrate(self, duration_ms: int = 400) -> None:
+        del duration_ms
+
+    def cancel(self) -> None:
+        pass
+
+
+class DesktopBattery:
+    def get_level(self) -> float:
+        return -1.0
+
+    def get_state(self) -> str:
+        return "unknown"
+
+
+class DesktopNetInfo:
+    def fetch(self) -> Optional[Dict[str, Any]]:
+        # ``None`` means "no fresh reading"; the facade keeps whatever
+        # snapshot was last dispatched (tests push those directly).
+        return None
+
+
+class DesktopPermissions:
+    def check(self, permission: str) -> str:
+        del permission
+        return "undetermined"
+
+    def request(self, permission: str) -> str:
+        del permission
+        return "undetermined"
+
+
+class DesktopNotifications:
+    def request_permission(self) -> bool:
+        return False
+
+    def schedule(self, title: str, body: str = "", delay_seconds: float = 0, identifier: str = "default") -> bool:
+        del title, body, delay_seconds, identifier
+        return False
+
+    def cancel(self, identifier: str = "default") -> None:
+        del identifier
+
+    def get_device_token(self) -> Optional[str]:
+        return None
+
+
+class DesktopCamera:
+    def take_photo(self) -> Optional[str]:
+        return None
+
+    def pick_from_gallery(self) -> Optional[str]:
+        return None
+
+
+class DesktopLocation:
+    def get_current(self) -> Optional[Dict[str, float]]:
+        return None
+
+
+class DesktopBiometrics:
+    def is_available(self) -> bool:
+        return False
+
+    def authenticate(self, reason: str = "Authenticate") -> bool:
+        del reason
+        return False
+
+
+_DEFAULTS: Dict[str, Callable[[], Any]] = {
+    "Device": DesktopDevice,
+    "AppState": DesktopAppState,
+    "Storage": DesktopStorage,
+    "SecureStore": DesktopSecureStore,
+    "Clipboard": DesktopClipboard,
+    "Alert": DesktopAlert,
+    "Share": DesktopShare,
+    "Linking": DesktopLinking,
+    "Haptics": DesktopHaptics,
+    "Battery": DesktopBattery,
+    "NetInfo": DesktopNetInfo,
+    "Permissions": DesktopPermissions,
+    "Notifications": DesktopNotifications,
+    "Camera": DesktopCamera,
+    "Location": DesktopLocation,
+    "Biometrics": DesktopBiometrics,
+}
+
+
+def default_implementation(name: str) -> Optional[Callable[[], Any]]:
+    """Return the factory for the built-in desktop implementation of ``name``."""
+    return _DEFAULTS.get(name)

pythonnative/native_modules/file_system.py

@@ -17,8 +17,9 @@ Example:
 import os
 from typing import Any, Optional
 
-from .. import diagnostics
-from ..utils import IS_ANDROID
+from .registry import native_module
+
+_app_dir_cache: Optional[str] = None
 
 
 class FileSystem:
@@ -39,31 +40,24 @@ class FileSystem:
         On Android the result is `Context.getFilesDir()`. On iOS it is
         the user's Documents directory. On a desktop machine without
         either runtime, a `.pythonnative_data` directory is created
-        under the user's home folder.
+        under the user's home folder. The value comes from the native
+        ``Device`` module's ``info()`` and is cached after the first
+        call.
 
         Returns:
             Absolute path to the app's data directory.
         """
-        if IS_ANDROID:
-            try:
-                from ..utils import get_android_context
-
-                return str(get_android_context().getFilesDir().getAbsolutePath())
-            except Exception:
-                diagnostics.swallowed("file_system.FileSystem.app_dir")
-        else:
+        global _app_dir_cache
+        if _app_dir_cache is None:
+            path: Optional[str] = None
             try:
-                from rubicon.objc import ObjCClass
-
-                NSSearchPathForDirectoriesInDomains = ObjCClass(
-                    "NSFileManager"
-                ).defaultManager.URLsForDirectory_inDomains_
-                docs = NSSearchPathForDirectoriesInDomains(9, 1)  # NSDocumentDirectory, NSUserDomainMask
-                if docs and docs.count > 0:
-                    return str(docs.objectAtIndex_(0).path)
+                info = native_module("Device").call("info")
+                if isinstance(info, dict):
+                    path = info.get("app_dir")
             except Exception:
-                diagnostics.swallowed("file_system.FileSystem.app_dir")
-        return os.path.join(os.path.expanduser("~"), ".pythonnative_data")
+                path = None
+            _app_dir_cache = str(path) if path else os.path.join(os.path.expanduser("~"), ".pythonnative_data")
+        return _app_dir_cache
 
     @staticmethod
     def read_text(path: str, encoding: str = "utf-8") -> Optional[str]: