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

pythonnative/native_modules/secure_store.py

@@ -1,10 +1,10 @@
 """Encrypted key/value storage for secrets (tokens, credentials).
 
 [`SecureStore`][pythonnative.SecureStore] persists small string values
-in the iOS Keychain and Android ``EncryptedSharedPreferences``, the
-right place for auth tokens and other secrets that
-[`AsyncStorage`][pythonnative.AsyncStorage] (plain, unencrypted) should
-never hold.
+in the iOS Keychain and Android ``EncryptedSharedPreferences`` (the
+native ``SecureStore`` module), the right place for auth tokens and
+other secrets that [`AsyncStorage`][pythonnative.AsyncStorage] (plain,
+unencrypted) should never hold.
 
 All methods are synchronous and return a ``bool`` (writes/deletes) or
 ``Optional[str]`` (reads). On desktop the module falls back to an
@@ -22,12 +22,9 @@ Example:
 
 from __future__ import annotations
 
-from typing import Dict, Optional
+from typing import Optional
 
-from ..utils import IS_ANDROID, IS_IOS
-
-_SERVICE = "com.pythonnative.securestore"
-_desktop_store: Dict[str, str] = {}
+from .registry import native_module
 
 
 class SecureStore:
@@ -36,158 +33,24 @@ class SecureStore:
     @staticmethod
     def set_item(key: str, value: str) -> bool:
         """Store ``value`` under ``key``. Returns ``True`` on success."""
-        if IS_IOS:
-            return _ios_set(key, value)
-        if IS_ANDROID:
-            return _android_set(key, value)
-        _desktop_store[key] = value
-        return True
+        try:
+            return bool(native_module("SecureStore").call("set_item", key=key, value=value))
+        except Exception:
+            return False
 
     @staticmethod
     def get_item(key: str) -> Optional[str]:
         """Return the value for ``key``, or ``None`` if absent."""
-        if IS_IOS:
-            return _ios_get(key)
-        if IS_ANDROID:
-            return _android_get(key)
-        return _desktop_store.get(key)
+        try:
+            value = native_module("SecureStore").call("get_item", key=key)
+        except Exception:
+            return None
+        return None if value is None else str(value)
 
     @staticmethod
     def delete_item(key: str) -> bool:
         """Delete ``key``. Returns ``True`` if it existed and was removed."""
-        if IS_IOS:
-            return _ios_delete(key)
-        if IS_ANDROID:
-            return _android_delete(key)
-        return _desktop_store.pop(key, None) is not None
-
-
-# ======================================================================
-# iOS: Security framework (Keychain)
-# ======================================================================
-
-
-def _ios_query(key: str) -> Dict[str, object]:
-    from rubicon.objc import ObjCClass
-
-    NSDictionary = ObjCClass("NSMutableDictionary")
-    query = NSDictionary.alloc().init()
-    query.setObject_forKey_("genp", "class")  # kSecClassGenericPassword shorthand
-    query.setObject_forKey_(_SERVICE, "svce")
-    query.setObject_forKey_(key, "acct")
-    return query
-
-
-def _ios_set(key: str, value: str) -> bool:
-    try:
-        from ctypes import CDLL, util
-
-        from rubicon.objc import ObjCClass
-
-        sec = CDLL(util.find_library("Security"))
-        query = _ios_query(key)
-        sec.SecItemDelete(query.ptr)
-        data = ObjCClass("NSString").stringWithString_(value).dataUsingEncoding_(4)  # UTF-8
-        query.setObject_forKey_(data, "v_Data")
-        status = sec.SecItemAdd(query.ptr, None)
-        return status == 0
-    except Exception:
-        return False
-
-
-def _ios_get(key: str) -> Optional[str]:
-    try:
-        from ctypes import CDLL, byref, c_void_p, util
-
-        from rubicon.objc import ObjCClass
-
-        sec = CDLL(util.find_library("Security"))
-        query = _ios_query(key)
-        query.setObject_forKey_(True, "r_Data")
-        query.setObject_forKey_("m_Limit_One", "m_Limit")
-        result = c_void_p(0)
-        status = sec.SecItemCopyMatching(query.ptr, byref(result))
-        if status != 0 or not result.value:
-            return None
-        data = ObjCClass("NSData").alloc()  # placeholder to keep import used
-        del data
-        ns = ObjCClass("NSString").alloc().initWithData_encoding_(result, 4)
-        return str(ns) if ns is not None else None
-    except Exception:
-        return None
-
-
-def _ios_delete(key: str) -> bool:
-    try:
-        from ctypes import CDLL, util
-
-        sec = CDLL(util.find_library("Security"))
-        return sec.SecItemDelete(_ios_query(key).ptr) == 0
-    except Exception:
-        return False
-
-
-# ======================================================================
-# Android: EncryptedSharedPreferences
-# ======================================================================
-
-
-def _android_prefs() -> Optional[object]:
-    try:
-        from java import jclass
-
-        from ..utils import get_android_context
-
-        ctx = get_android_context()
-        MasterKey = jclass("androidx.security.crypto.MasterKey")
-        Builder = jclass("androidx.security.crypto.MasterKey$Builder")
-        EncryptedSharedPreferences = jclass("androidx.security.crypto.EncryptedSharedPreferences")
-        KeyScheme = jclass("androidx.security.crypto.EncryptedSharedPreferences$PrefKeyEncryptionScheme")
-        ValueScheme = jclass("androidx.security.crypto.EncryptedSharedPreferences$PrefValueEncryptionScheme")
-        master = Builder(ctx).setKeyScheme(MasterKey.KeyScheme.AES256_GCM).build()
-        return EncryptedSharedPreferences.create(
-            ctx,
-            _SERVICE,
-            master,
-            KeyScheme.AES256_SIV,
-            ValueScheme.AES256_GCM,
-        )
-    except Exception:
-        return None
-
-
-def _android_set(key: str, value: str) -> bool:
-    prefs = _android_prefs()
-    if prefs is None:
-        return False
-    try:
-        editor = prefs.edit()
-        editor.putString(key, value)
-        return bool(editor.commit())
-    except Exception:
-        return False
-
-
-def _android_get(key: str) -> Optional[str]:
-    prefs = _android_prefs()
-    if prefs is None:
-        return None
-    try:
-        value = prefs.getString(key, None)
-        return str(value) if value is not None else None
-    except Exception:
-        return None
-
-
-def _android_delete(key: str) -> bool:
-    prefs = _android_prefs()
-    if prefs is None:
-        return False
-    try:
-        if not prefs.contains(key):
+        try:
+            return bool(native_module("SecureStore").call("delete_item", key=key))
+        except Exception:
             return False
-        editor = prefs.edit()
-        editor.remove(key)
-        return bool(editor.commit())
-    except Exception:
-        return False

pythonnative/native_modules/share.py

@@ -2,8 +2,8 @@
 
 [`Share.share`][pythonnative.Share] is a coroutine that opens
 ``UIActivityViewController`` (iOS) or an ``ACTION_SEND`` chooser
-(Android) and resolves to ``True`` once the user completes a share or
-``False`` if they dismiss it.
+(Android) through the native ``Share`` module and resolves to ``True``
+once the user completes a share or ``False`` if they dismiss it.
 
 Example:
     ```python
@@ -19,15 +19,9 @@ Example:
 
 from __future__ import annotations
 
-import asyncio
-from typing import Any, Callable, Dict, Optional
+from typing import Optional
 
-from .. import diagnostics
-from ..runtime import resolve_future
-from ..utils import IS_ANDROID, IS_IOS
-
-# Retain pool so iOS completion handlers aren't collected early.
-_pending: Dict[int, Any] = {}
+from .registry import native_module
 
 
 class Share:
@@ -51,106 +45,7 @@ class Share:
             ``True`` if the user completed a share, ``False`` if they
             cancelled or no share UI is available.
         """
-        loop = asyncio.get_running_loop()
-        future: asyncio.Future[bool] = loop.create_future()
-
-        def _done(ok: bool) -> None:
-            resolve_future(future, ok)
-
-        if IS_IOS:
-            _ios_share(_done, message=message, url=url, title=title)
-        elif IS_ANDROID:
-            _android_share(_done, message=message, url=url, title=title)
-        else:
-            _done(False)
-
-        return await future
-
-
-# ======================================================================
-# iOS: UIActivityViewController
-# ======================================================================
-
-
-def _ios_share(
-    on_done: Callable[[bool], None],
-    message: Optional[str],
-    url: Optional[str],
-    title: Optional[str],
-) -> None:
-    del title
-    try:
-        from rubicon.objc import Block, ObjCClass
-
-        items = ObjCClass("NSMutableArray").alloc().init()
-        if message:
-            items.addObject_(message)
-        if url:
-            nsurl = ObjCClass("NSURL").URLWithString_(url)
-            if nsurl is not None:
-                items.addObject_(nsurl)
-
-        controller = (
-            ObjCClass("UIActivityViewController").alloc().initWithActivityItems_applicationActivities_(items, None)
-        )
-
-        token = id(controller)
-        _pending[token] = controller
-
-        def _completion(activity: Any, completed: bool, items_: Any, error: Any) -> None:
-            del activity, items_, error
-            _pending.pop(token, None)
-            try:
-                on_done(bool(completed))
-            except Exception:
-                diagnostics.swallowed("share._ios_share._completion")
-
-        controller.setCompletionWithItemsHandler_(
-            Block(_completion, None, ObjCClass("NSString"), Block, ObjCClass("NSArray"), ObjCClass("NSError"))
-        )
-
-        app = ObjCClass("UIApplication").sharedApplication
-        top = app.keyWindow.rootViewController
-        while top is not None and top.presentedViewController is not None:
-            top = top.presentedViewController
-        if top is not None:
-            top.presentViewController_animated_completion_(controller, True, None)
-        else:
-            _pending.pop(token, None)
-            on_done(False)
-    except Exception:
-        on_done(False)
-
-
-# ======================================================================
-# Android: ACTION_SEND chooser
-# ======================================================================
-
-
-def _android_share(
-    on_done: Callable[[bool], None],
-    message: Optional[str],
-    url: Optional[str],
-    title: Optional[str],
-) -> None:
-    try:
-        from java import jclass
-
-        from ..utils import get_android_context
-
-        Intent = jclass("android.content.Intent")
-        intent = Intent(Intent.ACTION_SEND)
-        intent.setType("text/plain")
-        body = "\n".join(part for part in (message, url) if part)
-        intent.putExtra(Intent.EXTRA_TEXT, body)
-        if title:
-            intent.putExtra(Intent.EXTRA_SUBJECT, title)
-
-        chooser = Intent.createChooser(intent, title or "Share")
-        chooser.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
-        get_android_context().startActivity(chooser)
-        # ACTION_SEND chooser gives no completion callback; report
-        # success once the chooser has been launched.
-        on_done(True)
-    except Exception:
-        on_done(False)
+        try:
+            return bool(await native_module("Share").call_async("share", message=message, url=url, title=title))
+        except Exception:
+            return False

pythonnative/native_views/__init__.py

@@ -1,34 +1,25 @@
-"""Platform-specific native-view creation and update logic.
-
-This package provides the
-[`NativeViewRegistry`][pythonnative.native_views.NativeViewRegistry]
-that maps element type names (e.g., `"Text"`, `"Button"`) to
-platform-specific
-[`ViewHandler`][pythonnative.native_views.base.ViewHandler]
-implementations, and owns the **tag table** mapping each
-reconciler-assigned integer tag to its live native view.
-
-The reconciler communicates exclusively through
-[`apply_mutations`][pythonnative.native_views.NativeViewRegistry.apply_mutations]:
-one ordered batch of create/update/insert/remove/destroy/frame ops per
-commit (see `pythonnative.mutations`). Imperative escape hatches
-(commands, animation control, intrinsic measurement) resolve views
-through the same tag table.
-
-Platform handlers live in dedicated submodules:
-
-- `pythonnative.native_views.base`: shared `ViewHandler` protocol and
-  utilities.
-- `pythonnative.native_views.android`: Android handlers
-  (Chaquopy / Java bridge).
-- `pythonnative.native_views.ios`: iOS handlers (rubicon-objc).
-- `pythonnative.native_views.desktop`: Tkinter preview handlers.
-
-All platform-branching is handled at registration time via lazy
-imports, so this package can be imported on any platform for testing.
-A mock registry can be installed via
-[`set_registry`][pythonnative.native_views.set_registry] to drive the
-reconciler with no real native views.
+"""The view backend the reconciler commits to.
+
+The reconciler talks to exactly one object, obtained from
+[`get_registry`][pythonnative.native_views.get_registry], through a
+small protocol: ``apply_mutations`` (one ordered batch of
+create/update/insert/destroy/frame ops per commit, see
+`pythonnative.mutations`), ``resolve_view``, ``measure_intrinsic``,
+``command``, and the animation hooks. Two implementations exist:
+
+- [`BridgeBackend`][pythonnative.native_views.bridge_backend.BridgeBackend]
+  (iOS and Android): serializes each commit and hands it to the native
+  runtime through the bridge; Swift and Kotlin component managers own
+  every platform view. Python holds no native objects.
+- [`NativeViewRegistry`][pythonnative.native_views.NativeViewRegistry]
+  (desktop preview and tests): maps element type names to Python
+  [`ViewHandler`][pythonnative.native_views.base.ViewHandler]
+  implementations (`pythonnative.native_views.desktop` renders with
+  Tkinter) and owns the tag table itself.
+
+Platform selection happens lazily on first use, so this package
+imports on any platform. Tests install a mock with
+[`set_registry`][pythonnative.native_views.set_registry].
 """
 
 import math
@@ -292,98 +283,88 @@ class NativeViewRegistry:
 # Singleton registry
 # ======================================================================
 
-_registry: Optional[NativeViewRegistry] = None
+_registry: Any = None
 
 
-def _active_platform_name() -> str:
-    """Return ``"android"``, ``"desktop"``, or ``"ios"`` for the active runtime."""
-    from ..utils import IS_ANDROID, IS_DESKTOP
-
-    if IS_ANDROID:
-        return "android"
-    if IS_DESKTOP:
-        return "desktop"
-    return "ios"
-
-
-def _register_builtin_handlers(registry: NativeViewRegistry) -> None:
-    """Register every built-in handler for the active platform.
-
-    The desktop (Tkinter) backend is selected when ``pn preview`` sets
-    ``PN_PLATFORM=desktop``; otherwise this picks Android (on device) or
-    iOS (the default off-device path, exercised by the iOS templates and
-    by tests that install the ``[ios]`` extra). Off-device unit tests
-    typically inject a mock registry via ``set_registry`` instead.
-    """
-    from ..utils import IS_ANDROID, IS_DESKTOP
-
-    if IS_ANDROID:
-        from .android import register_handlers
-    elif IS_DESKTOP:
-        from .desktop import register_handlers
-    else:
-        from .ios import register_handlers
-    register_handlers(registry)
-
-
-def _install_sdk_handlers(registry: NativeViewRegistry) -> None:
+def _install_sdk_handlers(registry: Any) -> None:
     """Copy decorator-registered SDK handlers + entry-point plugins.
 
     Imported lazily so unit tests that never touch the SDK don't pay the
-    entry-point discovery cost.
+    entry-point discovery cost. Only meaningful for the Python-handler
+    registry (desktop / tests); on device the native runtime owns
+    component managers and Python handlers are recorded but never run.
     """
     try:
         from ..sdk._components import install_into_registry as _sdk_install
     except Exception:
         return
     try:
-        _sdk_install(registry, _active_platform_name())
+        _sdk_install(registry)
     except Exception:
         # A misbehaving plugin must not break PythonNative's startup.
         pass
 
 
-def get_registry() -> NativeViewRegistry:
-    """Return the process-wide registry, lazily registering handlers.
+def _create_backend() -> Any:
+    """Build the backend for the active platform.
+
+    iOS and Android get the bridge backend. ``pn preview``
+    (``PN_PLATFORM=desktop``) gets the Tkinter handler registry.
+    Anywhere else (plain unit tests) there is no renderer at all, so
+    the registry is empty: tests inject a
+    ``pythonnative.testing.FakeBackend`` with ``set_registry`` and a
+    stray commit raises a clear "unknown element type" rather than
+    silently importing a platform module.
+    """
+    from ..utils import IS_ANDROID, IS_DESKTOP, IS_IOS
+
+    if IS_IOS or IS_ANDROID:
+        from .bridge_backend import BridgeBackend
 
-    The first call instantiates the registry, registers either the
-    Android or iOS handlers based on `IS_ANDROID`, then layers on every
-    decorator-registered SDK handler (and any handlers exposed by
-    third-party packages via the
-    [`pythonnative.handlers`][pythonnative.sdk.ENTRY_POINT_GROUP] entry
-    point group). Subsequent calls return the same instance.
+        return BridgeBackend()
+    registry = NativeViewRegistry()
+    if IS_DESKTOP:
+        from .desktop import register_handlers
+
+        register_handlers(registry)
+    _install_sdk_handlers(registry)
+    return registry
+
+
+def get_registry() -> Any:
+    """Return the process-wide view backend, creating it on first use.
 
     Returns:
-        The active `NativeViewRegistry`.
+        A [`BridgeBackend`][pythonnative.native_views.bridge_backend.BridgeBackend]
+        on device, otherwise a `NativeViewRegistry` (Tkinter handlers
+        under ``pn preview``, plus every decorator-registered SDK
+        handler and any handlers exposed by third-party packages via
+        the [`pythonnative.handlers`][pythonnative.sdk.ENTRY_POINT_GROUP]
+        entry point group).
     """
     global _registry
     if _registry is not None:
         return _registry
-    _registry = NativeViewRegistry()
-    _register_builtin_handlers(_registry)
-    _install_sdk_handlers(_registry)
+    _registry = _create_backend()
     return _registry
 
 
-def refresh_registry() -> NativeViewRegistry:
-    """Re-run SDK handler installation against the existing registry.
+def refresh_registry() -> Any:
+    """Re-run SDK handler installation against the existing backend.
 
     Call this after registering a new component at runtime if the
     registry has already been instantiated. This is mostly useful in
     REPL sessions and tests; the normal flow is "register, then call
     [`get_registry`][pythonnative.native_views.get_registry]" and the
     handlers come along automatically.
-
-    Returns:
-        The active `NativeViewRegistry`.
     """
     registry = get_registry()
     _install_sdk_handlers(registry)
     return registry
 
 
-def set_registry(registry: Optional[NativeViewRegistry]) -> None:
-    """Install a custom registry (primarily for testing).
+def set_registry(registry: Any) -> None:
+    """Install a custom backend (primarily for testing).
 
     Replaces the lazy singleton so subsequent
     [`get_registry`][pythonnative.native_views.get_registry] calls
@@ -393,7 +374,7 @@ def set_registry(registry: Optional[NativeViewRegistry]) -> None:
     rebuild it from scratch.
 
     Args:
-        registry: The replacement registry, or ``None`` to clear.
+        registry: The replacement backend, or ``None`` to clear.
     """
     global _registry
     _registry = registry