pythonnative 0.40.0__cp313-cp313-win_amd64.whl

pythonnative/layout.py

@@ -0,0 +1,328 @@
+"""Yoga 3.2.1 layout for headless tests and the Python preview host.
+
+Mobile hosts run this same pinned core beside their native widgets. This
+module contains style translation and ownership, not a second flex algorithm.
+"""
+
+from __future__ import annotations
+
+import ctypes as C
+import math
+import weakref
+from typing import Any, Callable
+
+LAYOUT_STYLE_KEYS = frozenset(
+    {
+        "width",
+        "height",
+        "min_width",
+        "max_width",
+        "min_height",
+        "max_height",
+        "flex",
+        "flex_grow",
+        "flex_shrink",
+        "flex_basis",
+        "flex_wrap",
+        "align_self",
+        "align_content",
+        "position",
+        "top",
+        "right",
+        "bottom",
+        "left",
+        "start",
+        "end",
+        "margin",
+        "margin_top",
+        "margin_bottom",
+        "margin_left",
+        "margin_right",
+        "margin_start",
+        "margin_end",
+        "margin_horizontal",
+        "margin_vertical",
+        "padding",
+        "padding_top",
+        "padding_bottom",
+        "padding_left",
+        "padding_right",
+        "padding_start",
+        "padding_end",
+        "padding_horizontal",
+        "padding_vertical",
+        "border_width",
+        "border_top_width",
+        "border_right_width",
+        "border_bottom_width",
+        "border_left_width",
+        "flex_direction",
+        "justify_content",
+        "align_items",
+        "spacing",
+        "gap",
+        "row_gap",
+        "column_gap",
+        "aspect_ratio",
+        "direction",
+        "display",
+    }
+)
+"""Style keys that affect layout (and are consumed by the layout engine)."""
+
+
+_lib: Any = None
+_nodes: weakref.WeakValueDictionary[int, LayoutNode] = weakref.WeakValueDictionary()
+_Measure = C.CFUNCTYPE(
+    None, C.c_void_p, C.c_float, C.c_int, C.c_float, C.c_int, C.POINTER(C.c_float), C.POINTER(C.c_float)
+)
+
+
+@_Measure
+def _measure(ptr: int, width: float, wm: int, height: float, hm: int, outw: Any, outh: Any) -> None:
+    node = _nodes.get(ptr)
+    try:
+        w, h = node.measure(width if wm else math.inf, height if hm else math.inf)
+        outw[0], outh[0] = max(0, w), max(0, h)
+    except BaseException as exc:
+        if node is not None:
+            node._error = exc
+        outw[0] = outh[0] = 0
+
+
+def _api() -> Any:
+    global _lib
+    if _lib is not None:
+        return _lib
+    from . import _yoga
+
+    lib = C.CDLL(_yoga.__file__)
+    signatures: dict[str, Any] = {
+        "YGNodeNew": (C.c_void_p, []),
+        "YGNodeFree": (None, [C.c_void_p]),
+        "YGNodeRemoveAllChildren": (None, [C.c_void_p]),
+        "YGNodeInsertChild": (None, [C.c_void_p, C.c_void_p, C.c_size_t]),
+        "YGNodeCopyStyle": (None, [C.c_void_p, C.c_void_p]),
+        "YGNodeMarkDirty": (None, [C.c_void_p]),
+        "YGNodeCalculateLayout": (None, [C.c_void_p, C.c_float, C.c_float, C.c_int]),
+        "pn_yoga_callback": (None, [_Measure]),
+        "pn_yoga_measure": (None, [C.c_void_p, C.c_int]),
+    }
+    for axis in ("Left", "Top", "Width", "Height"):
+        signatures["YGNodeLayoutGet" + axis] = (C.c_float, [C.c_void_p])
+    for name, (result, args) in signatures.items():
+        fn = getattr(lib, name)
+        fn.restype, fn.argtypes = result, args
+    lib.pn_yoga_callback(_measure)
+    _lib = lib
+    return lib
+
+
+# Enum order follows Yoga's public C ABI in the pinned vendored headers.
+ENUMS = {
+    "direction": ("Direction", ["inherit", "ltr", "rtl"]),
+    "flex_direction": ("FlexDirection", ["column", "column_reverse", "row", "row_reverse"]),
+    "justify_content": (
+        "JustifyContent",
+        ["flex_start", "center", "flex_end", "space_between", "space_around", "space_evenly"],
+    ),
+    "align_items": (
+        "AlignItems",
+        [
+            "auto",
+            "flex_start",
+            "center",
+            "flex_end",
+            "stretch",
+            "baseline",
+            "space_between",
+            "space_around",
+            "space_evenly",
+        ],
+    ),
+    "align_self": (
+        "AlignSelf",
+        [
+            "auto",
+            "flex_start",
+            "center",
+            "flex_end",
+            "stretch",
+            "baseline",
+            "space_between",
+            "space_around",
+            "space_evenly",
+        ],
+    ),
+    "align_content": (
+        "AlignContent",
+        [
+            "auto",
+            "flex_start",
+            "center",
+            "flex_end",
+            "stretch",
+            "baseline",
+            "space_between",
+            "space_around",
+            "space_evenly",
+        ],
+    ),
+    "position": ("PositionType", ["static", "relative", "absolute"]),
+    "flex_wrap": ("FlexWrap", ["nowrap", "wrap", "wrap_reverse"]),
+    "display": ("Display", ["flex", "none", "contents"]),
+}
+EDGES = {
+    name: i
+    for i, name in enumerate(["left", "top", "right", "bottom", "start", "end", "horizontal", "vertical", "all"])
+}
+ALIASES = {
+    "start": "flex_start",
+    "leading": "flex_start",
+    "top": "flex_start",
+    "end": "flex_end",
+    "trailing": "flex_end",
+    "bottom": "flex_end",
+    "fill": "stretch",
+}
+
+
+def _set(ptr: int, name: str, value: Any, edge: int | None = None, *, enum: bool = False) -> None:
+    if value is None or isinstance(value, bool):
+        return
+    suffix = ""
+    args: list[Any] = [ptr]
+    types: list[Any] = [C.c_void_p]
+    if edge is not None:
+        args.append(edge)
+        types.append(C.c_int)
+    if value == "auto":
+        suffix = "Auto"
+    else:
+        if isinstance(value, str) and value.endswith("%"):
+            suffix, value = "Percent", float(value[:-1])
+        args.append(int(value) if enum else float(value))
+        types.append(C.c_int if enum else C.c_float)
+    fn = getattr(_api(), "YGNodeStyleSet" + name + suffix)
+    fn.restype, fn.argtypes = None, types
+    fn(*args)
+
+
+def apply_style(ptr: int, style: dict[str, Any]) -> None:
+    """Translate Pythonic style keys to Yoga's native style API."""
+    for key, value in style.items():
+        if value is None:
+            continue
+        if key in ENUMS:
+            name, values = ENUMS[key]
+            value = ALIASES.get(value, value) if key.startswith(("align_", "justify_")) else value
+            if value not in values:
+                raise ValueError(f"Invalid {key}: {value!r}")
+            _set(ptr, name, values.index(value), enum=True)
+        elif key in {
+            "width",
+            "height",
+            "min_width",
+            "min_height",
+            "max_width",
+            "max_height",
+            "flex",
+            "flex_grow",
+            "flex_shrink",
+            "flex_basis",
+            "aspect_ratio",
+        }:
+            _set(ptr, "".join(part.title() for part in key.split("_")), value)
+        elif key in {"spacing", "gap", "row_gap", "column_gap"}:
+            _set(ptr, "Gap", value, {"column_gap": 0, "row_gap": 1}.get(key, 2))
+        elif key in EDGES and key not in {"all", "horizontal", "vertical"}:
+            _set(ptr, "Position", value, EDGES[key])
+        elif key.startswith(("padding", "margin")):
+            group, _, edge = key.partition("_")
+            if isinstance(value, dict):
+                for side, amount in value.items():
+                    _set(ptr, group.title(), amount, EDGES[side])
+            else:
+                _set(ptr, group.title(), value, EDGES[edge or "all"])
+        elif key.startswith("border_") and key.endswith("width"):
+            _set(ptr, "Border", value, EDGES[key[7:-6] or "all"])
+
+
+class LayoutNode:
+    """An owned Yoga node, with Python measurement for headless backends."""
+
+    def __init__(
+        self,
+        style: dict[str, Any] | None = None,
+        children: list[LayoutNode] | None = None,
+        measure: Callable[[float, float], tuple[float, float]] | None = None,
+        user_data: Any = None,
+    ) -> None:
+        self.style = dict(style or {})
+        self.children = list(children or [])
+        self.measure = measure
+        self.user_data = user_data
+        self.x = self.y = self.width = self.height = 0.0
+        self.dirty = True
+        self._pn_scroll_axis: str | None = None
+        self._ptr: int | None = None
+        self._last_style: Any = None
+        self._last_children: tuple[int, ...] = ()
+        self._error: BaseException | None = None
+
+    def _sync(self) -> int:
+        lib = _api()
+        if self._ptr is None:
+            self._ptr = lib.YGNodeNew()
+            _nodes[self._ptr] = self
+            weakref.finalize(self, lib.YGNodeFree, self._ptr)
+        ptr = self._ptr
+        style = dict(self.style)
+        if self._pn_scroll_axis:
+            style.setdefault("flex_shrink", 1)
+        if style != self._last_style:
+            fresh = lib.YGNodeNew()
+            apply_style(fresh, style)
+            if self._pn_scroll_axis:
+                _set(fresh, "Overflow", 1, enum=True)
+            lib.YGNodeCopyStyle(ptr, fresh)
+            lib.YGNodeFree(fresh)
+            self._last_style = style
+        measured = self.measure is not None and not self.children
+        lib.pn_yoga_measure(ptr, measured)
+        if measured and self.dirty:
+            lib.YGNodeMarkDirty(ptr)
+        children = tuple(child._sync() for child in self.children)
+        if children != self._last_children:
+            lib.YGNodeRemoveAllChildren(ptr)
+            for i, child in enumerate(children):
+                lib.YGNodeInsertChild(ptr, child, i)
+            self._last_children = children
+        return ptr
+
+    def _read(self) -> None:
+        lib = _api()
+        self.x = lib.YGNodeLayoutGetLeft(self._ptr)
+        self.y = lib.YGNodeLayoutGetTop(self._ptr)
+        self.width = lib.YGNodeLayoutGetWidth(self._ptr)
+        self.height = lib.YGNodeLayoutGetHeight(self._ptr)
+        self.dirty = False
+        if self._error is not None:
+            error, self._error = self._error, None
+            raise error
+        for child in self.children:
+            child._read()
+
+
+def calculate_layout(node: LayoutNode, width: float, height: float) -> None:
+    """Calculate a tree's layout with the pinned Yoga core."""
+    ptr = node._sync()
+    _api().YGNodeCalculateLayout(
+        ptr, width if math.isfinite(width) else math.nan, height if math.isfinite(height) else math.nan, 1
+    )
+    node._read()
+
+
+def extract_layout_style(props: dict[str, Any]) -> dict[str, Any]:
+    """Select properties owned by layout."""
+    return {key: value for key, value in props.items() if key in LAYOUT_STYLE_KEYS}

pythonnative/mutations.py

@@ -0,0 +1,142 @@
+"""Batched mutation protocol between the reconciler and native backends.
+
+The reconciler no longer talks to the native layer one call at a time.
+Instead, every commit pass produces an ordered list of small mutation
+ops referencing integer **tags** (stable per-view identifiers), and the
+whole list is applied in a single
+[`apply_mutations`][pythonnative.native_views.NativeViewRegistry.apply_mutations]
+call. This mirrors React Native's Fabric mounting layer: the diff phase
+is pure, and the native side sees one coherent transaction per commit.
+
+Why tags instead of view objects?
+
+- The diff phase runs *before* any native view exists, so ops cannot
+  reference views directly.
+- Tags give the native side a stable identity to key its own view
+  registry, event routing, and animation bookkeeping on.
+- A flat list of `(op, tag, payload)` tuples is trivially serializable,
+  which keeps the door open for applying mutations from a background
+  thread or through a single JNI/ObjC crossing in the future.
+
+Op ordering rules (the reconciler guarantees these):
+
+1. A `CreateOp` for a tag precedes any other op referencing that tag.
+2. `InsertOp` ops appear after both the parent and child exist.
+3. `DestroyOp` ops are emitted children-first; handlers detach the view
+   from its parent as part of destruction.
+4. `SetFrameOp` ops are only emitted for frames that actually changed
+   since the last layout pass (frame diffing).
+"""
+
+from dataclasses import dataclass, field
+from typing import Any, Dict, Tuple, Union
+
+__all__ = [
+    "CreateOp",
+    "UpdateOp",
+    "InsertOp",
+    "DestroyOp",
+    "SetFrameOp",
+    "Mutation",
+]
+
+
+@dataclass(frozen=True)
+class CreateOp:
+    """Create a native view for ``tag`` of element type ``type_name``.
+
+    Attributes:
+        tag: Unique integer identity assigned by the reconciler.
+        type_name: Element type name (e.g. ``"Text"``).
+        props: Initial *clean* props; callables have already been
+            routed to the [`EventRegistry`][pythonnative.events.EventRegistry]
+            and replaced by the ``_pn_events`` name set.
+    """
+
+    tag: int
+    type_name: str
+    props: Dict[str, Any] = field(default_factory=dict)
+
+
+@dataclass(frozen=True)
+class UpdateOp:
+    """Apply ``changed_props`` to the view registered under ``tag``.
+
+    Removed props are signaled with a value of ``None``, matching the
+    pre-existing handler contract.
+
+    Attributes:
+        tag: Unique integer identity of the target view.
+        changed_props: Mapping of modified prop names to their new values.
+            Removed props appear with a value of ``None``.
+    """
+
+    tag: int
+    changed_props: Dict[str, Any] = field(default_factory=dict)
+
+
+@dataclass(frozen=True)
+class InsertOp:
+    """Ensure the child view sits at ``index`` inside the parent view.
+
+    Handlers must treat this as *move-aware*: if the child is already
+    attached to the parent at a different position, it is moved rather
+    than duplicated. ``index`` is clamped by handlers to the current
+    child count.
+
+    Attributes:
+        parent_tag: Integer tag of the container view.
+        child_tag: Integer tag of the child view to insert or move.
+        index: Zero-based insertion index, clamped by handlers to the
+            current child count.
+    """
+
+    parent_tag: int
+    child_tag: int
+    index: int
+
+
+@dataclass(frozen=True)
+class DestroyOp:
+    """Release the native view registered under ``tag``.
+
+    The registry drops its tag record and calls the handler's
+    ``destroy`` hook so platform resources (listeners, timers, image
+    loads) can be released eagerly instead of waiting for GC.
+
+    Attributes:
+        tag: Unique integer identity of the view to destroy.
+    """
+
+    tag: int
+
+
+@dataclass(frozen=True)
+class SetFrameOp:
+    """Position and size the view registered under ``tag``.
+
+    Coordinates are points relative to the parent's content origin,
+    exactly as computed by the layout engine.
+
+    Attributes:
+        tag: Unique integer identity of the target view.
+        x: Horizontal origin offset in points relative to the parent.
+        y: Vertical origin offset in points relative to the parent.
+        width: View width in points.
+        height: View height in points.
+    """
+
+    tag: int
+    x: float
+    y: float
+    width: float
+    height: float
+
+    @property
+    def frame(self) -> Tuple[float, float, float, float]:
+        """Return ``(x, y, width, height)`` as a tuple."""
+        return (self.x, self.y, self.width, self.height)
+
+
+Mutation = Union[CreateOp, UpdateOp, InsertOp, DestroyOp, SetFrameOp]
+"""Union of every op type carried by a commit transaction."""

pythonnative/native/android/build.gradle

@@ -0,0 +1,52 @@
+plugins {
+    id 'com.android.library'
+    id 'org.jetbrains.kotlin.android'
+}
+
+android {
+    namespace 'com.pythonnative.runtime'
+    compileSdk 34
+
+    defaultConfig {
+        minSdk 24
+        testInstrumentationRunner "androidx.test.runner.AndroidJUnitRunner"
+    }
+
+    externalNativeBuild {
+        cmake { path "src/main/cpp/CMakeLists.txt"; version "3.22.1" }
+    }
+
+    buildFeatures {
+        buildConfig false
+    }
+
+    compileOptions {
+        sourceCompatibility JavaVersion.VERSION_1_8
+        targetCompatibility JavaVersion.VERSION_1_8
+    }
+    kotlinOptions {
+        jvmTarget = '1.8'
+    }
+
+    testOptions {
+        unitTests.returnDefaultValues = true
+    }
+}
+
+dependencies {
+    api 'androidx.core:core-ktx:1.8.0'
+    api 'androidx.appcompat:appcompat:1.4.1'
+    api 'com.google.android.material:material:1.5.0'
+    api 'androidx.recyclerview:recyclerview:1.3.2'
+    api 'androidx.swiperefreshlayout:swiperefreshlayout:1.1.0'
+    api 'androidx.security:security-crypto:1.1.0'
+    api 'androidx.biometric:biometric:1.1.0'
+    api 'androidx.dynamicanimation:dynamicanimation:1.0.0'
+    // Screen navigation (PNScreenFragment inside the app's NavHostFragment).
+    api 'androidx.navigation:navigation-fragment-ktx:2.7.7'
+    api 'androidx.navigation:navigation-ui-ktx:2.7.7'
+
+    testImplementation 'junit:junit:4.13.2'
+    // Real org.json for host-side unit tests (the android.jar stubs are empty).
+    testImplementation 'org.json:json:20231013'
+}

pythonnative/native/android/gradle.properties

@@ -0,0 +1,3 @@
+android.useAndroidX=true
+android.nonTransitiveRClass=true
+org.gradle.jvmargs=-Xmx2048m -Dfile.encoding=UTF-8

pythonnative/native/android/settings.gradle

@@ -0,0 +1,12 @@
+pluginManagement {
+    repositories { google(); mavenCentral(); gradlePluginPortal() }
+    plugins {
+        id 'com.android.library' version '8.7.3'
+        id 'org.jetbrains.kotlin.android' version '2.0.21'
+    }
+}
+dependencyResolutionManagement {
+    repositoriesMode.set(RepositoriesMode.FAIL_ON_PROJECT_REPOS)
+    repositories { google(); mavenCentral() }
+}
+rootProject.name = 'PythonNativeRuntime'

pythonnative/native/android/src/main/AndroidManifest.xml

@@ -0,0 +1,11 @@
+<?xml version="1.0" encoding="utf-8"?>
+<manifest xmlns:android="http://schemas.android.com/apk/res/android">
+
+    <!-- Runtime-gated on Android 13+ (API 33); requested by the
+         Notifications module before posting. -->
+    <uses-permission android:name="android.permission.POST_NOTIFICATIONS" />
+    <uses-permission android:name="android.permission.VIBRATE" />
+    <uses-permission android:name="android.permission.INTERNET" />
+    <uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />
+
+</manifest>

pythonnative/native/android/src/main/cpp/CMakeLists.txt

@@ -0,0 +1,9 @@
+cmake_minimum_required(VERSION 3.22)
+project(pn_yoga LANGUAGES CXX)
+set(CMAKE_CXX_STANDARD 20)
+set(PN_YOGA_ROOT ${CMAKE_CURRENT_LIST_DIR}/../../../../yoga)
+file(GLOB_RECURSE YOGA_SOURCES ${PN_YOGA_ROOT}/yoga/*.cpp)
+add_library(pn_yoga SHARED ${YOGA_SOURCES} ${PN_YOGA_ROOT}/style.cpp yoga_jni.cpp)
+target_include_directories(pn_yoga PRIVATE ${PN_YOGA_ROOT})
+target_link_libraries(pn_yoga log)
+target_link_options(pn_yoga PRIVATE "-Wl,-z,max-page-size=16384")

pythonnative/native/android/src/main/cpp/yoga_jni.cpp

@@ -0,0 +1,52 @@
+#include <jni.h>
+#include <yoga/Yoga.h>
+#include <include/PNStyle.h>
+#include <cmath>
+static JavaVM* vm;
+extern "C" JNIEXPORT jint JNI_OnLoad(JavaVM* value, void*) { vm = value; return JNI_VERSION_1_6; }
+static JNIEnv* env() { JNIEnv* result; vm->GetEnv(reinterpret_cast<void**>(&result), JNI_VERSION_1_6); return result; }
+static YGNodeRef node(jlong ptr) { return reinterpret_cast<YGNodeRef>(ptr); }
+static YGSize measure(YGNodeConstRef n, float w, YGMeasureMode wm, float h, YGMeasureMode hm) {
+    auto e = env(); auto object = static_cast<jobject>(YGNodeGetContext(n));
+    auto cls = e->GetObjectClass(object);
+    auto method = e->GetMethodID(cls, "measure", "(FF)[F");
+    auto result = static_cast<jfloatArray>(e->CallObjectMethod(object, method, wm == YGMeasureModeUndefined ? 1e6f : w, hm == YGMeasureModeUndefined ? 1e6f : h));
+    float size[2] = {0, 0};
+    if (result) { e->GetFloatArrayRegion(result, 0, 2, size); e->DeleteLocalRef(result); }
+    e->DeleteLocalRef(cls);
+    return {size[0], size[1]};
+}
+static float baseline(YGNodeConstRef n, float, float h) {
+    auto e = env(); auto object = static_cast<jobject>(YGNodeGetContext(n));
+    auto cls = e->GetObjectClass(object);
+    auto method = e->GetMethodID(cls, "baseline", "(F)F");
+    float result = e->CallFloatMethod(object, method, h); e->DeleteLocalRef(cls); return result;
+}
+#define JNI(name) extern "C" JNIEXPORT name
+JNI(jlong) Java_com_pythonnative_runtime_layout_YogaNode_create(JNIEnv* e, jobject self) {
+    auto n = YGNodeNew(); YGNodeSetContext(n, e->NewGlobalRef(self)); return reinterpret_cast<jlong>(n);
+}
+JNI(void) Java_com_pythonnative_runtime_layout_YogaNode_free(JNIEnv* e, jobject, jlong ptr) {
+    auto n = node(ptr); e->DeleteGlobalRef(static_cast<jobject>(YGNodeGetContext(n))); YGNodeFree(n);
+}
+JNI(void) Java_com_pythonnative_runtime_layout_YogaNode_style(JNIEnv* e, jobject, jlong ptr, jstring key, jstring value) {
+    auto k = e->GetStringUTFChars(key, nullptr); auto v = e->GetStringUTFChars(value, nullptr);
+    PNYogaSetStyle(node(ptr), k, v); e->ReleaseStringUTFChars(key, k); e->ReleaseStringUTFChars(value, v);
+}
+JNI(void) Java_com_pythonnative_runtime_layout_YogaNode_resetStyle(JNIEnv*, jobject, jlong ptr) {
+    auto fresh = YGNodeNew(); YGNodeCopyStyle(node(ptr), fresh); YGNodeFree(fresh);
+}
+JNI(void) Java_com_pythonnative_runtime_layout_YogaNode_measureLeaf(JNIEnv*, jobject, jlong ptr, jboolean enabled) {
+    YGNodeSetMeasureFunc(node(ptr), enabled ? measure : nullptr);
+    YGNodeSetBaselineFunc(node(ptr), enabled ? baseline : nullptr);
+    if (enabled) YGNodeMarkDirty(node(ptr));
+}
+JNI(void) Java_com_pythonnative_runtime_layout_YogaNode_insert(JNIEnv*, jobject, jlong ptr, jlong child, jint index) {
+    auto n = node(ptr); YGNodeSetMeasureFunc(n, nullptr); YGNodeInsertChild(n, node(child), index);
+}
+JNI(void) Java_com_pythonnative_runtime_layout_YogaNode_remove(JNIEnv*, jobject, jlong ptr, jlong child) { YGNodeRemoveChild(node(ptr), node(child)); }
+JNI(void) Java_com_pythonnative_runtime_layout_YogaNode_calculate(JNIEnv*, jobject, jlong ptr, jfloat w, jfloat h) { YGNodeCalculateLayout(node(ptr), w, h, YGDirectionLTR); }
+JNI(jfloatArray) Java_com_pythonnative_runtime_layout_YogaNode_frame(JNIEnv* e, jobject, jlong ptr) {
+    auto n = node(ptr); float values[] = {YGNodeLayoutGetLeft(n), YGNodeLayoutGetTop(n), YGNodeLayoutGetWidth(n), YGNodeLayoutGetHeight(n)};
+    auto result = e->NewFloatArray(4); e->SetFloatArrayRegion(result, 0, 4, values); return result;
+}

pythonnative/native/android/src/main/java/com/pythonnative/generated/NativeModules.kt

@@ -0,0 +1,5 @@
+package com.pythonnative.generated
+
+import org.json.JSONObject
+import com.pythonnative.runtime.modules.NativeModule
+import com.pythonnative.runtime.modules.Promise