pythonnative 0.32.0__py3-none-any.whl → 0.34.0__py3-none-any.whl

pythonnative/scheduler.py

@@ -0,0 +1,159 @@
+"""Update scheduling primitives shared by hooks and the reconciler.
+
+Two pieces live here:
+
+- [`batch_updates`][pythonnative.scheduler.batch_updates], a context manager that
+  coalesces the render triggers fired by several state setters into
+  one, tracked per execution context (so it composes with ``async``
+  code).
+- [`TransitionQueue`][pythonnative.scheduler.TransitionQueue], the
+  per-reconciler queue behind
+  [`use_transition`][pythonnative.use_transition]: renders marked as
+  transitions are deferred to a later turn of the framework loop so
+  urgent updates (typing, presses) stay responsive.
+
+Nothing here is global mutable state beyond context variables, so
+several reconcilers (screens, list rows, tests) never interfere.
+"""
+
+from __future__ import annotations
+
+from contextlib import contextmanager
+from contextvars import ContextVar
+from typing import Callable, Generator, List, Optional
+
+from . import diagnostics
+
+__all__ = ["TransitionQueue", "batch_updates", "in_transition", "run_in_transition", "schedule_trigger"]
+
+# Depth of nested ``batch_updates`` blocks plus the triggers deferred by
+# the outermost block, per execution context.
+_batch_depth: ContextVar[int] = ContextVar("pn_batch_depth", default=0)
+_batch_pending: ContextVar[Optional[List[Callable[[], None]]]] = ContextVar("pn_batch_pending", default=None)
+
+# Whether state updates in the current execution context are marked as
+# transitions (see ``use_transition``).
+_transition_var: ContextVar[bool] = ContextVar("pn_transition", default=False)
+
+
+def schedule_trigger(trigger: Callable[[], None]) -> None:
+    """Run ``trigger`` now, or defer it to the end of the enclosing ``batch_updates`` block."""
+    pending = _batch_pending.get()
+    if _batch_depth.get() > 0 and pending is not None:
+        if trigger not in pending:
+            pending.append(trigger)
+    else:
+        trigger()
+
+
+@contextmanager
+def batch_updates() -> Generator[None, None, None]:
+    """Coalesce multiple state updates into a single re-render.
+
+    State setters called inside the ``with`` block defer their
+    re-render trigger until the block exits, so any number of
+    ``set_*`` calls produce at most one render pass.
+
+    Example:
+        ```python
+        import pythonnative as pn
+
+        with pn.batch_updates():
+            set_count(1)
+            set_name("hello")
+        ```
+    """
+    depth = _batch_depth.get()
+    depth_token = _batch_depth.set(depth + 1)
+    pending_token = None
+    if depth == 0:
+        pending_token = _batch_pending.set([])
+    try:
+        yield
+    finally:
+        _batch_depth.reset(depth_token)
+        if pending_token is not None:
+            triggers = _batch_pending.get() or []
+            _batch_pending.reset(pending_token)
+            for trigger in triggers:
+                trigger()
+
+
+def in_transition() -> bool:
+    """Whether state updates in the current context are transitions."""
+    return _transition_var.get()
+
+
+def run_in_transition(fn: Callable[[], None]) -> None:
+    """Run ``fn`` with its state updates marked as transitions."""
+    token = _transition_var.set(True)
+    try:
+        fn()
+    finally:
+        _transition_var.reset(token)
+
+
+class TransitionQueue:
+    """Deferred render triggers and completion callbacks for one reconciler.
+
+    Triggers added via [`defer`][pythonnative.scheduler.TransitionQueue.defer]
+    run together on a later loop turn; callbacks added via
+    [`on_complete`][pythonnative.scheduler.TransitionQueue.on_complete]
+    run right after them (this is how ``use_transition`` flips its
+    ``is_pending`` flag back off once the deferred render committed).
+    """
+
+    __slots__ = ("_triggers", "_callbacks", "_scheduled")
+
+    def __init__(self) -> None:
+        self._triggers: List[Callable[[], None]] = []
+        self._callbacks: List[Callable[[], None]] = []
+        self._scheduled = False
+
+    def defer(self, trigger: Callable[[], None]) -> None:
+        """Queue ``trigger`` for the next flush."""
+        if trigger not in self._triggers:
+            self._triggers.append(trigger)
+        self._ensure_scheduled()
+
+    def on_complete(self, callback: Callable[[], None]) -> None:
+        """Queue ``callback`` to run after the next flush's triggers."""
+        self._callbacks.append(callback)
+        self._ensure_scheduled()
+
+    @property
+    def pending(self) -> bool:
+        """Whether a flush is scheduled or work is queued."""
+        return self._scheduled or bool(self._triggers) or bool(self._callbacks)
+
+    def flush(self) -> None:
+        """Run every deferred trigger, then the completion callbacks."""
+        self._scheduled = False
+        triggers = self._triggers
+        callbacks = self._callbacks
+        self._triggers = []
+        self._callbacks = []
+        for fn in triggers + callbacks:
+            try:
+                fn()
+            except Exception as exc:
+                if not diagnostics.report_error(exc, phase="transition"):
+                    raise
+
+    def clear(self) -> None:
+        """Drop queued work (used on unmount)."""
+        self._triggers = []
+        self._callbacks = []
+        self._scheduled = False
+
+    def _ensure_scheduled(self) -> None:
+        if self._scheduled:
+            return
+        self._scheduled = True
+        from .runtime import get_loop
+
+        get_loop().call_soon(self._flush_if_scheduled)
+
+    def _flush_if_scheduled(self) -> None:
+        if self._scheduled:
+            self.flush()

pythonnative/sdk/_components.py

@@ -170,9 +170,7 @@ def native_component(
 
     def decorator(handler_cls: Type[H]) -> Type[H]:
         if not isinstance(handler_cls, type) or not issubclass(handler_cls, ViewHandler):
-            raise TypeError(
-                f"@native_component({name!r}) must decorate a ViewHandler subclass; " f"got {handler_cls!r}"
-            )
+            raise TypeError(f"@native_component({name!r}) must decorate a ViewHandler subclass; got {handler_cls!r}")
         register_component(name=name, props=props, handlers={plat: handler_cls() for plat in plats})
         return handler_cls
 
@@ -385,7 +383,7 @@ def element_factory(name: str) -> Callable[..., Element]:
     """
     if name not in _REGISTRY:
         raise KeyError(
-            f"No component registered under name {name!r}. " "Use @native_component or register_component first."
+            f"No component registered under name {name!r}. Use @native_component or register_component first."
         )
 
     def factory(*children: Element, key: Optional[str] = None, props: Any = None, **kwargs: Any) -> Element:

pythonnative/style.py

@@ -35,7 +35,7 @@ Example:
 """
 
 import difflib
-from typing import Any, Dict, List, Literal, Optional, Tuple, TypedDict, Union
+from typing import Any, Dict, List, Literal, Optional, Tuple, TypedDict, Union, get_args
 
 from . import diagnostics
 from .hooks import Context, create_context, use_color_scheme, use_context
@@ -107,6 +107,11 @@ class ShadowOffset(TypedDict):
     height: float
 
 
+ShadowOffsetValue = Union[ShadowOffset, Tuple[float, float], List[float]]
+"""``shadow_offset`` / ``text_shadow_offset`` value: an
+[`ShadowOffset`][pythonnative.ShadowOffset] dict or an ``(x, y)`` pair."""
+
+
 # ----------------------------------------------------------------------
 # Transforms
 # ----------------------------------------------------------------------
@@ -192,6 +197,7 @@ AlignItems = Literal[
     "flex_start",
     "center",
     "flex_end",
+    "baseline",
     "auto",
     "start",
     "leading",
@@ -203,9 +209,18 @@ AlignItems = Literal[
 ]
 AlignSelf = AlignItems
 Position = Literal["relative", "absolute"]
+Display = Literal["flex", "none"]
+"""``display`` style value. ``"none"`` removes the node and its subtree
+from layout entirely (no size, gap, or margin contribution; every frame
+in the subtree is ``(0, 0, 0, 0)``)."""
 Overflow = Literal["visible", "hidden", "scroll"]
 TextAlign = Literal["left", "center", "right", "justify", "start", "end"]
 TextDecoration = Literal["none", "underline", "line_through"]
+TextTransform = Literal["none", "uppercase", "lowercase", "capitalize"]
+"""``text_transform`` style value. Applied in Python before the string
+reaches the native label, so measurement and rendering agree."""
+MarginValue = Union[Dimension, Literal["auto"]]
+"""A margin length: points, a ``"%"`` string, or ``"auto"`` to absorb free space."""
 FontWeight = Literal[
     "normal",
     "bold",
@@ -294,6 +309,7 @@ class Style(TypedDict, total=False):
     align_self: AlignSelf
     align_content: AlignContent
     direction: LayoutDirection
+    display: Display
 
     # --- Layout: position ---
     position: Position
@@ -314,15 +330,15 @@ class Style(TypedDict, total=False):
     padding_end: Dimension
     padding_horizontal: Dimension
     padding_vertical: Dimension
-    margin: EdgeValue
-    margin_top: Dimension
-    margin_bottom: Dimension
-    margin_left: Dimension
-    margin_right: Dimension
-    margin_start: Dimension
-    margin_end: Dimension
-    margin_horizontal: Dimension
-    margin_vertical: Dimension
+    margin: Union[MarginValue, EdgeInsets]
+    margin_top: MarginValue
+    margin_bottom: MarginValue
+    margin_left: MarginValue
+    margin_right: MarginValue
+    margin_start: MarginValue
+    margin_end: MarginValue
+    margin_horizontal: MarginValue
+    margin_vertical: MarginValue
     spacing: float
     gap: float
     row_gap: float
@@ -362,13 +378,17 @@ class Style(TypedDict, total=False):
     italic: bool
     text_align: TextAlign
     text_decoration: TextDecoration
+    text_transform: TextTransform
     line_height: float
     letter_spacing: float
     max_lines: int
+    text_shadow_color: Color
+    text_shadow_offset: ShadowOffsetValue
+    text_shadow_radius: float
 
     # --- Visual: shadows / effects ---
     shadow_color: Color
-    shadow_offset: Union[ShadowOffset, Tuple[float, float], List[float]]
+    shadow_offset: ShadowOffsetValue
     shadow_opacity: float
     shadow_radius: float
     elevation: float
@@ -447,6 +467,49 @@ def resolve_style(value: StyleProp) -> Dict[str, Any]:
 _KNOWN_STYLE_KEYS = frozenset(Style.__annotations__)
 """Every key declared on the [`Style`][pythonnative.Style] TypedDict."""
 
+_STYLE_VALUE_CHOICES: Dict[str, frozenset] = {
+    "display": frozenset(get_args(Display)),
+    "position": frozenset(get_args(Position)),
+    "direction": frozenset(get_args(LayoutDirection)),
+    "text_decoration": frozenset(get_args(TextDecoration)),
+    "text_transform": frozenset(get_args(TextTransform)),
+    "pointer_events": frozenset(get_args(PointerEvents)),
+}
+"""Keys whose string values are checked against their ``Literal`` choices
+in dev mode. Only keys whose handlers accept exactly the declared
+literals are listed, so friendly aliases (``align_items: "leading"``,
+``font_weight: "semibold"``) never trigger false positives."""
+
+
+def _is_number(value: Any) -> bool:
+    return isinstance(value, (int, float)) and not isinstance(value, bool)
+
+
+def _text_shadow_offset_ok(value: Any) -> bool:
+    if isinstance(value, dict):
+        return all(_is_number(value.get(k, 0)) for k in ("width", "height"))
+    if isinstance(value, (tuple, list)) and len(value) == 2:
+        return all(_is_number(v) for v in value)
+    return False
+
+
+def _bad_value_message(key: str, value: Any) -> Optional[str]:
+    """Return a description of why ``value`` is invalid for ``key``, or ``None``."""
+    choices = _STYLE_VALUE_CHOICES.get(key)
+    if choices is not None:
+        if not isinstance(value, str) or value not in choices:
+            allowed = ", ".join(repr(c) for c in sorted(choices))
+            return f"Invalid value {value!r} for style key {key!r}; expected one of {allowed}."
+        return None
+    if key == "text_shadow_offset" and not _text_shadow_offset_ok(value):
+        return (
+            f"Invalid value {value!r} for style key 'text_shadow_offset'; "
+            "expected {'width': x, 'height': y} or an (x, y) pair."
+        )
+    if key == "text_shadow_radius" and (not _is_number(value) or value < 0):
+        return f"Invalid value {value!r} for style key 'text_shadow_radius'; expected a non-negative number."
+    return None
+
 
 def validate_style_keys(style_dict: Dict[str, Any], owner: str = "") -> None:
     """Warn (once per key) about style keys no built-in handler reads.
@@ -457,6 +520,13 @@ def validate_style_keys(style_dict: Dict[str, Any], owner: str = "") -> None:
     to handlers untouched, so custom components that read extra keys
     keep working (at the cost of one dev warning).
 
+    A small set of enum-shaped keys (``display``, ``position``,
+    ``direction``, ``text_decoration``, ``text_transform``,
+    ``pointer_events``) and the ``text_shadow_*`` keys also have their
+    values checked; a bad value warns once per key/value pair and is
+    otherwise passed through (the engine and handlers ignore values
+    they don't recognize).
+
     Args:
         style_dict: The flattened style dict about to be merged into an
             element's props.
@@ -465,8 +535,16 @@ def validate_style_keys(style_dict: Dict[str, Any], owner: str = "") -> None:
     """
     if not diagnostics.is_dev() or not style_dict:
         return
-    for key in style_dict:
+    for key, value in style_dict.items():
         if key in _KNOWN_STYLE_KEYS:
+            if value is None:
+                continue
+            problem = _bad_value_message(key, value)
+            if problem is not None:
+                diagnostics.warn_once(
+                    problem + (f" (on {owner})" if owner else ""),
+                    key=f"style-value:{owner}:{key}:{value!r}",
+                )
             continue
         matches = difflib.get_close_matches(str(key), _KNOWN_STYLE_KEYS, n=1)
         hint = f" Did you mean {matches[0]!r}?" if matches else ""
@@ -621,7 +699,7 @@ Without a provider, [`use_theme`][pythonnative.use_theme] resolves to
 [`DEFAULT_LIGHT_THEME`][pythonnative.style.DEFAULT_LIGHT_THEME] or
 [`DEFAULT_DARK_THEME`][pythonnative.style.DEFAULT_DARK_THEME] based on
 the current appearance. Wrap a subtree in
-[`Provider(ThemeContext, my_theme, ...)`][pythonnative.Provider] to
+[`ThemeContext.Provider(my_theme, ...)`][pythonnative.hooks.Context.Provider] to
 pin an explicit theme for that subtree, then read it inside
 descendants via [`use_theme`][pythonnative.use_theme] (or
 [`use_context(ThemeContext)`][pythonnative.use_context]).
@@ -676,23 +754,27 @@ __all__ = [
     "DEFAULT_DARK_THEME",
     "DEFAULT_LIGHT_THEME",
     "Dimension",
+    "Display",
     "EdgeInsets",
     "EdgeValue",
     "FlexDirection",
     "FontWeight",
     "JustifyContent",
     "KeyboardType",
+    "MarginValue",
     "Overflow",
     "PointerEvents",
     "Position",
     "ReturnKeyType",
     "ScaleType",
     "ShadowOffset",
+    "ShadowOffsetValue",
     "Style",
     "StyleProp",
     "StyleSheet",
     "TextAlign",
     "TextDecoration",
+    "TextTransform",
     "ThemeContext",
     "TransformEntry",
     "TransformRotate",

pythonnative/suspense.py

@@ -386,26 +386,22 @@ def lazy(loader: Callable[[], Any]) -> Callable[..., Any]:
             )
         ```
     """
-    from .hooks import component
+    from .component import Component
 
     state: dict = {}
 
-    @component
-    def Lazy(**props: Any) -> Any:
+    def Lazy(*children: Any, **props: Any) -> Any:
         resource = state.get("resource")
         if resource is None:
             resource = start_resource(loader)
             state["resource"] = resource
         loaded = resource.read()
-        children = props.pop("children", None)
-        if children:
-            return loaded(*children, **props)
-        return loaded(**props)
-
-    Lazy.__name__ = getattr(loader, "__name__", "Lazy")
-    if Lazy.__name__ == "<lambda>":
-        Lazy.__name__ = "Lazy"
-    return Lazy
+        return loaded(*children, **props)
+
+    name = getattr(loader, "__name__", "Lazy")
+    if name == "<lambda>":
+        name = "Lazy"
+    return Component(Lazy, display_name=name)
 
 
 __all__ = [

pythonnative/templates/android_template/app/src/main/java/com/pythonnative/android_template/MainActivity.kt

@@ -1,7 +1,10 @@
 package com.pythonnative.android_template
 
+import android.content.BroadcastReceiver
 import android.content.Context
 import android.content.Intent
+import android.content.IntentFilter
+import android.os.BatteryManager
 import android.graphics.Color
 import android.graphics.Typeface
 import android.net.ConnectivityManager
@@ -20,6 +23,7 @@ class MainActivity : AppCompatActivity() {
     private val TAG = javaClass.simpleName
     private var pythonReady = false
     private var networkCallback: ConnectivityManager.NetworkCallback? = null
+    private var batteryReceiver: BroadcastReceiver? = null
 
     override fun onCreate(savedInstanceState: Bundle?) {
         super.onCreate(savedInstanceState)
@@ -42,7 +46,7 @@ class MainActivity : AppCompatActivity() {
             }
             // Import the entry module now so a broken app fails here,
             // with a full traceback, instead of inside the first fragment.
-            py.getModule("app.main")
+            py.getModule(getString(R.string.pn_entry_module))
             pythonReady = true
         } catch (e: Exception) {
             Log.e("PythonNative", "Bootstrap failed", e)
@@ -54,10 +58,19 @@ class MainActivity : AppCompatActivity() {
         intent?.dataString?.let { dispatchUrl(it) }
 
         registerNetworkCallback()
+        registerBatteryReceiver()
     }
 
     override fun onDestroy() {
         super.onDestroy()
+        batteryReceiver?.let {
+            try {
+                unregisterReceiver(it)
+            } catch (e: Exception) {
+                Log.e("PythonNative", "unregisterReceiver(battery) failed", e)
+            }
+            batteryReceiver = null
+        }
         networkCallback?.let {
             try {
                 (getSystemService(Context.CONNECTIVITY_SERVICE) as ConnectivityManager)
@@ -69,6 +82,35 @@ class MainActivity : AppCompatActivity() {
         }
     }
 
+    @Deprecated("Deprecated in Java")
+    override fun onActivityResult(requestCode: Int, resultCode: Int, data: Intent?) {
+        super.onActivityResult(requestCode, resultCode, data)
+        if (!pythonReady) return
+        try {
+            Python.getInstance()
+                .getModule("pythonnative.native_modules")
+                .callAttr("dispatch_activity_result", requestCode, resultCode, data)
+        } catch (e: Exception) {
+            Log.e("PythonNative", "dispatch_activity_result failed", e)
+        }
+    }
+
+    override fun onRequestPermissionsResult(
+        requestCode: Int,
+        permissions: Array<out String>,
+        grantResults: IntArray
+    ) {
+        super.onRequestPermissionsResult(requestCode, permissions, grantResults)
+        if (!pythonReady) return
+        try {
+            Python.getInstance()
+                .getModule("pythonnative.native_modules")
+                .callAttr("dispatch_permissions_result", requestCode, permissions.toList(), grantResults.toList())
+        } catch (e: Exception) {
+            Log.e("PythonNative", "dispatch_permissions_result failed", e)
+        }
+    }
+
     override fun onNewIntent(intent: Intent) {
         super.onNewIntent(intent)
         setIntent(intent)
@@ -143,6 +185,48 @@ class MainActivity : AppCompatActivity() {
         }
     }
 
+    // MARK: - Battery forwarding
+
+    // ACTION_BATTERY_CHANGED is a sticky broadcast, so registering also
+    // delivers the current level immediately.
+    private fun registerBatteryReceiver() {
+        if (!pythonReady || batteryReceiver != null) return
+        try {
+            val receiver = object : BroadcastReceiver() {
+                override fun onReceive(context: Context?, intent: Intent?) {
+                    if (intent == null) return
+                    val level = intent.getIntExtra(BatteryManager.EXTRA_LEVEL, -1)
+                    val scale = intent.getIntExtra(BatteryManager.EXTRA_SCALE, -1)
+                    val status = intent.getIntExtra(BatteryManager.EXTRA_STATUS, -1)
+                    val fraction = if (level >= 0 && scale > 0) level.toDouble() / scale.toDouble() else -1.0
+                    val state = when (status) {
+                        BatteryManager.BATTERY_STATUS_CHARGING -> "charging"
+                        BatteryManager.BATTERY_STATUS_FULL -> "full"
+                        BatteryManager.BATTERY_STATUS_DISCHARGING,
+                        BatteryManager.BATTERY_STATUS_NOT_CHARGING -> "unplugged"
+                        else -> "unknown"
+                    }
+                    dispatchBattery(fraction, state)
+                }
+            }
+            registerReceiver(receiver, IntentFilter(Intent.ACTION_BATTERY_CHANGED))
+            batteryReceiver = receiver
+        } catch (e: Exception) {
+            Log.e("PythonNative", "registerReceiver(battery) failed", e)
+        }
+    }
+
+    private fun dispatchBattery(level: Double, state: String) {
+        if (!pythonReady) return
+        try {
+            Python.getInstance()
+                .getModule("pythonnative.native_modules.battery")
+                .callAttr("dispatch_battery", level, state)
+        } catch (e: Exception) {
+            Log.e("PythonNative", "dispatch_battery failed", e)
+        }
+    }
+
     // MARK: - Deep links
 
     private fun dispatchUrl(url: String) {

pythonnative/templates/android_template/app/src/main/java/com/pythonnative/android_template/ScreenFragment.kt

@@ -38,18 +38,17 @@ class ScreenFragment : Fragment() {
         }
         try {
             val py = Python.getInstance()
-            // Default to "app.main": PythonNative imports the module
-            // and looks up its top-level `App` attribute. Override
-            // via fragment arguments / nav graph to load a different
-            // module or a specific dotted-attribute path (e.g.
-            // "app.main.RootScreen").
-            val screenPath = arguments?.getString("screen_path") ?: "app.main"
+            // PythonNative imports the entry module (app.entry_point in
+            // pythonnative.toml, staged into R.string.pn_entry_module)
+            // and looks up its top-level `App` attribute. Pushed screens
+            // pass an explicit path in the fragment arguments.
+            val screenPath = arguments?.getString("screen_path") ?: getString(R.string.pn_entry_module)
             val argsJson = arguments?.getString("args_json")
             val filesRoot = requireContext().filesDir.absolutePath
             val devRoot = "$filesRoot/pythonnative_dev"
             val hotReload = py.getModule("pythonnative.hot_reload")
             hotReload.callAttr("configure_dev_environment", filesRoot)
-            val pnScreen = py.getModule("pythonnative.screen")
+            val pnScreen = py.getModule("pythonnative.hosts")
             screen = pnScreen.callAttr("create_screen", screenPath, requireActivity(), argsJson)
             screen?.callAttr("enable_hot_reload", "$devRoot/reload.json", devRoot)
         } catch (e: Exception) {

pythonnative/templates/android_template/app/src/main/res/navigation/nav_graph.xml

@@ -12,7 +12,7 @@
         <argument
             android:name="screen_path"
             app:argType="string"
-            android:defaultValue="app.main" />
+            app:nullable="true" />
         <argument
             android:name="args_json"
             app:argType="string"

pythonnative/templates/android_template/app/src/main/res/values/strings.xml

@@ -1,3 +1,5 @@
 <resources>
     <string name="app_name">android_template</string>
-</resources>
+    <!-- Dotted module whose top-level `App` is mounted; set from app.entry_point by `pn build`. -->
+    <string name="pn_entry_module" translatable="false">app.main</string>
+</resources>

pythonnative/templates/ios_template/ios_template/AppDelegate.swift

@@ -16,9 +16,42 @@ class AppDelegate: UIResponder, UIApplicationDelegate {
         _ application: UIApplication,
         didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?
     ) -> Bool {
+        registerBatteryObservers()
         return true
     }
 
+    // MARK: - Battery forwarding
+
+    // UIDevice only posts battery notifications while monitoring is on;
+    // Battery.add_listener subscribers receive {"level", "state"}.
+    private func registerBatteryObservers() {
+        UIDevice.current.isBatteryMonitoringEnabled = true
+        let center = NotificationCenter.default
+        for name in [UIDevice.batteryLevelDidChangeNotification, UIDevice.batteryStateDidChangeNotification] {
+            center.addObserver(forName: name, object: nil, queue: .main) { _ in
+                self.dispatchBattery()
+            }
+        }
+    }
+
+    private func dispatchBattery() {
+        guard PythonRuntime.shared.started else { return }
+        let device = UIDevice.current
+        let state: String
+        switch device.batteryState {
+        case .unplugged: state = "unplugged"
+        case .charging: state = "charging"
+        case .full: state = "full"
+        default: state = "unknown"
+        }
+        PythonRuntime.shared.notify(
+            module: "pythonnative.native_modules.battery",
+            function: "dispatch_battery",
+            Double(device.batteryLevel),
+            state
+        )
+    }
+
     // MARK: - Remote notifications (APNs)
 
     func application(

pythonnative/templates/ios_template/ios_template/PythonRuntime.swift

@@ -392,6 +392,6 @@ final class PythonRuntime {
 public func pn_schedule_render_drain() {
     DispatchQueue.main.async {
         guard PythonRuntime.shared.started else { return }
-        PythonRuntime.shared.notify(module: "pythonnative.screen", function: "drain_ios_scheduled_renders")
+        PythonRuntime.shared.notify(module: "pythonnative.hosts", function: "drain_ios_scheduled_renders")
     }
 }