pythonx-compose 0.1.0a1__py3-none-any.whl → 0.1.0a3__py3-none-any.whl

pythonx/compose/__init__.pyi

@@ -1 +1 @@
-# GENERATED by scripts/gen_stubs.py from python-multiplatform's Kotlin-named stubs (artifact kotlin-stubs, workflow run 37103737430, commit a5028618, Compose 1.11.1). Do not edit.
+# GENERATED by scripts/gen_stubs.py from python-multiplatform's Kotlin-named stubs (artifact ks, workflow run 42402779166, commit 9507e6dd, Compose 1.11.1-ext.2). Do not edit.

pythonx/compose/_reexport.py

@@ -1,33 +1,29 @@
 """The one rule that makes a `pythonx.compose.*` module a Pythonic view of a Kotlin package.
 
-The binder (`python-multiplatform`) serves every bound Kotlin package under its **Kotlin** name --
-`androidx.compose.foundation.layout` -- with Kotlin's own surface: declaration names, keyword
-arguments by Kotlin parameter name, Kotlin defaults, overload dispatch. It renames nothing, and it
-publishes what a Pythonic layer needs to rename by rule: `inspect.signature(fn)` with the Kotlin
-parameter names, and `python_multiplatform.describe(fn)` with one dict per overload.
+The binder (`python-multiplatform`) serves every bound Kotlin package under its **Kotlin** name
+(`androidx.compose.foundation.layout`), and since its #131 it also serves the Pythonic spellings
+itself: snake_case names and keyword arguments, by this module's rule (`python_name`), with the
+Kotlin spelling still working and `inspect.signature` reporting the snake_case keywords. It never
+renames a namespace: `pythonx` is this package.
 
-This module is that layer. A mapped package's `__init__.py` is one line::
+This module groups those Kotlin packages into `pythonx.compose.*`. A mapped package's `__init__.py`
+is one line::
 
     __getattr__, __dir__ = reexport(__name__)
 
 and every name in it then resolves against the Kotlin package `pythonx-map.toml` maps it to:
 
-- **Names.** A name that starts upper-case -- a type, an object, a `@Composable` -- keeps its Kotlin
-  spelling (`Modifier`, `Text`). Any other name is reached by its snake_case spelling only
+- **Names.** A name that starts upper-case (a type, an object, a `@Composable`) keeps its Kotlin
+  spelling (`Modifier`, `Text`). Any other name is listed and reached by its snake_case spelling
   (`fillMaxWidth` -> `fill_max_width`, `toURLString` -> `to_url_string`), and an explicit overload
-  keeps its suffix (`padding__Dp`). The inverse is never computed: the module's real Kotlin names
-  are converted forward and looked up, so a name the reverse rule could not invert still resolves.
-- **Keywords.** `on_click=` reaches the parameter Kotlin calls `onClick`, matched against the
-  declaration's own parameter names (every overload's), never derived.
-- **Signatures.** A re-exported function answers `inspect.signature` with the snake_case names;
-  defaults stay `python_multiplatform.KOTLIN_DEFAULT`.
+  keeps its suffix (`padding__Dp`). The rule is applied forward to the module's real Kotlin names,
+  so a name the reverse rule could not invert still resolves.
+- **Functions** are the binder's own callables; their keywords and signatures are the binder's.
 - **Value classes.** The manifest's `raw-primitive-allowed` list is handed to the binder once per
   installed binding layer, so `padding(16)` reaches a `Dp` parameter.
-- **Methods on a proxy.** The same name rule is registered as the binder's member resolver, so
-  `Modifier.padding(16).fill_max_width()` reaches `fillMaxWidth` on a proxy Kotlin returned, and
-  `m.padding(padding_values=...)` reaches `paddingValues`: the resolver also answers a keyword map,
-  read from `python_multiplatform.describe_member`. The Kotlin spelling still works. The binder
-  caches the alias in its own registry; its proxy classes keep Kotlin names in `dir()`.
+- **Methods on a proxy** are the binder's: since python-multiplatform #131 it serves
+  `Modifier.padding(16).fill_max_width()` and `m.padding(padding_values=...)` itself, by this
+  package's rule, with the Kotlin spelling still working. Nothing here takes part.
 
 - **Grouped constants.** Inside a Kotlin object served as a namespace, a type nested in it that
   is not one of its members groups the constants declared as exactly that type, so the notebook's
@@ -50,13 +46,14 @@ from __future__ import annotations
 
 import importlib
 import importlib.util
-import inspect
 import re
 import sys
 import types
 import weakref
+from collections.abc import Callable, Iterable, Mapping
 from functools import lru_cache
 from pathlib import Path
+from typing import Protocol, TypedDict, cast
 
 ROOT_MODULE = "python_multiplatform"
 BINDING_MODULE = "python_multiplatform.binding"
@@ -66,6 +63,30 @@ _MANIFEST = Path(__file__).resolve().parent / "pythonx-map.toml"
 _LOWER_UPPER = re.compile(r"([a-z0-9])([A-Z])")
 _ACRONYM_WORD = re.compile(r"([A-Z]+)([A-Z][a-z])")
 
+# `pythonx-map.toml`'s shape. Its tables are keyed by Kotlin and module names, so the hyphenated
+# keys are spelled in the functional form.
+_ValueClasses = TypedDict("_ValueClasses", {"raw-primitive-allowed": list[str]}, total=False)
+Manifest = TypedDict(
+    "Manifest",
+    {
+        "modules": dict[str, str],
+        "value-classes": _ValueClasses,
+        "aliases": dict[str, dict[str, "list[str] | dict[str, str]"]],
+    },
+    total=False,
+)
+
+
+class BindingLayer(Protocol):
+    """What this module asks of `python_multiplatform.binding`."""
+
+    def allow_raw_primitive(self, kotlin_type: str, /) -> None: ...
+    def register_empty(self, kotlin_type: object, empty_factory: object, /) -> None: ...
+
+
+Describe = Callable[[types.ModuleType, str], object]
+"""`python_multiplatform.describe(module, name)`."""
+
 
 def snake_case(kotlin_name: str) -> str:
     """`fillMaxWidth` -> `fill_max_width`, `toURLString` -> `to_url_string`, `zIndex` -> `z_index`."""
@@ -85,12 +106,12 @@ def python_name(kotlin_name: str) -> str:
 
 
 @lru_cache(maxsize=1)
-def manifest() -> dict:
+def manifest() -> Manifest:
     """`pythonx-map.toml`, parsed once."""
     import tomllib
 
     with _MANIFEST.open("rb") as handle:
-        return tomllib.load(handle)
+        return cast(Manifest, tomllib.load(handle))
 
 
 def kotlin_package_of(module_name: str) -> str:
@@ -102,7 +123,7 @@ def kotlin_package_of(module_name: str) -> str:
         ) from None
 
 
-def binding_layer():
+def binding_layer() -> BindingLayer:
     """The binder's installed binding module, or a `RuntimeError` that says what did not happen."""
     binding = sys.modules.get(BINDING_MODULE)
     if binding is None:
@@ -110,95 +131,47 @@ def binding_layer():
             "the python-multiplatform binding layer is not installed: the Kotlin host must run "
             "PythonxAdapter.install() before pythonx.compose can resolve a Kotlin declaration"
         )
-    return binding
-
-
-_PRIMED = weakref.WeakSet()
-
+    return cast(BindingLayer, binding)
 
-_MEMBER_KEYWORDS: "weakref.WeakKeyDictionary" = weakref.WeakKeyDictionary()
 
+_PRIMED: weakref.WeakSet[BindingLayer] = weakref.WeakSet()
+_MODIFIER_TYPE = "androidx.compose.ui.Modifier"
 
-def _method_keywords(kotlin_type_name: str, kotlin_member_name: str) -> dict:
-    """`{snake_case(p): p}` for every parameter `p` of every declaration of a proxy's member.
 
-    Read with `python_multiplatform.describe_member`, which lists each overload's parameters without
-    invoking anything (the receiver slot is not among them). It is metadata, so it is kept per
-    (type, member), under the `describe_member` of the binding layer that answered: a new layer
-    starts with an empty table. A keyword whose snake_case spelling is its own is left out, and a
-    binder without `describe_member`, or a member it does not describe, has no map.
-    """
-    describe_member = getattr(sys.modules.get(ROOT_MODULE), "describe_member", None)
-    if describe_member is None:
-        return {}
-    try:
-        known = _MEMBER_KEYWORDS.setdefault(describe_member, {})
-    except TypeError:  # something that cannot be weakly referenced: nothing to key a cache by
-        known = {}
-    key = (kotlin_type_name, kotlin_member_name)
-    if key not in known:
-        keywords: dict = {}
-        try:
-            declarations = describe_member(kotlin_type_name, kotlin_member_name)
-        except (TypeError, AttributeError):
-            declarations = ()
-        for declaration in declarations:
-            for parameter in declaration.get("parameters", ()):
-                kotlin_parameter = parameter.get("name")
-                if kotlin_parameter and snake_case(kotlin_parameter) != kotlin_parameter:
-                    keywords.setdefault(snake_case(kotlin_parameter), kotlin_parameter)
-        known[key] = keywords
-    return known[key]
-
-
-def member_name(kotlin_type_name: str, requested: str, kotlin_member_names):
-    """The binder's member-resolver hook: the Kotlin member a Pythonic name means on a proxy, and
-    the keywords it takes.
-
-    The binder asks for a name its proxy has no Kotlin member of
-    (`python_multiplatform.binding.add_member_resolver`): the rule is the module rule applied
-    forward to the proxy's real member names, so `fill_max_width` finds `fillMaxWidth`. It asks
-    again for a Kotlin member name when a call passes keywords. The answer is then
-    `(kotlin_name, {python_keyword: kotlinParameter})`, the parameters of every overload of that
-    member, so `m.padding(padding_values=...)` reaches `paddingValues`. Without a keyword to map the
-    answer is the name alone, which is all a binder without `describe_member` can be given.
-    """
-    if requested in kotlin_member_names:
-        target = requested
-    else:
-        matches = [name for name in kotlin_member_names if python_name(name) == requested]
-        target = matches[0] if len(matches) == 1 else None
-    if target is None:
-        return None
-    keywords = _method_keywords(kotlin_type_name, target)
-    return (target, keywords) if keywords else target
+def _modifier_companion() -> object:
+    """`Modifier.Companion` read live from `androidx.compose.ui.Modifier` (python-multiplatform #324)."""
+    return cast(object, importlib.import_module("androidx.compose.ui").Modifier.Companion)
 
 
-def _prime(binding) -> None:
-    """Hand this binding layer the manifest's value-class allowlist and the member rule, once.
+def _prime(binding: BindingLayer) -> None:
+    """Hand this binding layer the manifest's value-class allowlist and the default empty `Modifier`, once.
 
-    The member rule needs python-multiplatform's `add_member_resolver`; on a binder without it,
-    methods on a returned proxy stay reachable by their Kotlin names only.
+    Method names and keywords on a proxy are the binder's own since python-multiplatform #131
+    (snake_case by this package's rule); nothing is registered for them here. Since
+    python-multiplatform #324, `Modifier.Companion` is bound as a value on the proxy class and
+    `register_empty` accepts a callable (`SPEC.md` S6.2, #138); if the caller has not already
+    registered an explicit empty factory for `androidx.compose.ui.Modifier`, `_modifier_companion`
+    is registered as the default.
     """
     if binding in _PRIMED:
         return
     for kotlin_type in manifest().get("value-classes", {}).get("raw-primitive-allowed", ()):
         binding.allow_raw_primitive(kotlin_type)
-    add_member_resolver = getattr(binding, "add_member_resolver", None)
-    if add_member_resolver is not None:
-        add_member_resolver(member_name)
+    factories = cast("Mapping[str, object]", getattr(binding, "_EMPTY_FACTORIES", {}))
+    if _MODIFIER_TYPE not in factories:
+        binding.register_empty(_MODIFIER_TYPE, _modifier_companion)
     _PRIMED.add(binding)
 
 
-def kotlin_module(module_name: str):
+def kotlin_module(module_name: str) -> types.ModuleType:
     """The binder's module for the Kotlin package `module_name` maps to."""
     _prime(binding_layer())
     return importlib.import_module(kotlin_package_of(module_name))
 
 
-def _name_table(kotlin) -> dict:
+def _name_table(kotlin: types.ModuleType) -> dict[str, str]:
     """Pythonic name -> Kotlin name for everything the Kotlin module reports, with collisions refused."""
-    table = {}
+    table: dict[str, str] = {}
     for kotlin_name in dir(kotlin):
         if kotlin_name.startswith("_"):
             continue
@@ -213,7 +186,7 @@ def _name_table(kotlin) -> dict:
     return table
 
 
-def _declared_type(kotlin, kotlin_name: str):
+def _declared_type(kotlin: types.ModuleType, kotlin_name: str) -> tuple[object, str | None] | None:
     """`(kind, declared return type)` of the bound name [kotlin_name] in [kotlin], without reading it.
 
     `python_multiplatform.describe(module, name)` answers from the binder's table and never runs a
@@ -221,7 +194,7 @@ def _declared_type(kotlin, kotlin_name: str):
     that is not a single bound declaration (an overload set, a child package), answers `None`.
     """
     root = sys.modules.get(ROOT_MODULE)
-    describe = getattr(root, "describe", None)
+    describe = cast("Describe | None", getattr(root, "describe", None))
     if describe is None:
         return None
     try:
@@ -230,78 +203,23 @@ def _declared_type(kotlin, kotlin_name: str):
         return None
     if not isinstance(described, dict):
         return None
-    return described.get("kind"), described.get("returns")
+    # The binder's answer is a plain dict of strings; its values are only compared and sliced here.
+    answer = cast(dict[str, object], described)
+    returns = answer.get("returns")
+    return answer.get("kind"), returns if isinstance(returns, str) else None
 
 
-def _describe(fn):
-    root = sys.modules.get(ROOT_MODULE)
-    if root is None or not hasattr(root, "describe"):
-        return ()
-    try:
-        return root.describe(fn)
-    except (TypeError, AttributeError):
-        return ()
-
-
-class PythonicFunction:
-    """A binder callable seen through the naming rule: snake_case keywords and signature.
-
-    Calls go straight to the binder's callable with the keywords translated; overload selection,
-    defaults and value classes are the binder's. A keyword that matches no parameter is passed on
-    unchanged, so the binder's own refusal -- which lists the candidates -- is what the caller sees.
-    """
-
-    __slots__ = ("_kotlin", "_keywords", "__name__", "__qualname__")
-
-    def __init__(self, kotlin_fn, name):
-        self._kotlin = kotlin_fn
-        self.__name__ = name
-        self.__qualname__ = name
-        keywords = {}
-        for row in _describe(kotlin_fn):
-            for parameter in row.get("parameters", ()):
-                kotlin_parameter = parameter["name"]
-                keywords.setdefault(snake_case(kotlin_parameter), kotlin_parameter)
-        self._keywords = keywords
-
-    @property
-    def __kotlin__(self):
-        """The binder's callable this wraps."""
-        return self._kotlin
-
-    @property
-    def __kotlin_rows__(self):
-        return self._kotlin.__kotlin_rows__
-
-    @property
-    def __signature__(self):
-        kotlin_signature = inspect.signature(self._kotlin)
-        return kotlin_signature.replace(parameters=[
-            parameter if parameter.kind in (parameter.VAR_POSITIONAL, parameter.VAR_KEYWORD)
-            else parameter.replace(name=snake_case(parameter.name))
-            for parameter in kotlin_signature.parameters.values()
-        ])
-
-    def __call__(self, *args, **kwargs):
-        if kwargs:
-            kwargs = {self._keywords.get(key, key): value for key, value in kwargs.items()}
-        return self._kotlin(*args, **kwargs)
-
-    def __repr__(self):
-        return f"<pythonx function {self.__name__} -> {self._kotlin!r}>"
-
-
-def _pythonic(value, name):
+def _pythonic(value: object) -> object:
     if isinstance(value, types.ModuleType):
         # A Kotlin object served as a sub-package. Since python-multiplatform #35 the binder lists it
         # and exposes it as an attribute of its parent, so the name table reaches it directly.
-        return KotlinObject(value)
-    if isinstance(value, type) or not callable(value):
-        return value
-    return PythonicFunction(value, name)
+        return _kotlin_object(value)
+    # A function is the binder's own callable: since python-multiplatform #131 it takes snake_case
+    # keywords and reports them in `inspect.signature` itself.
+    return value
 
 
-def _resolve(kotlin, name: str):
+def _resolve(kotlin: types.ModuleType, name: str) -> tuple[object, bool] | None:
     """What the Pythonic [name] means in the binder's module [kotlin]: `(value, cacheable)` or `None`.
 
     A name the module lists is looked up by the rule. An upper-case name it does not list may be a
@@ -311,23 +229,23 @@ def _resolve(kotlin, name: str):
     """
     kotlin_name = _name_table(kotlin).get(name)
     if kotlin_name is not None:
-        value = getattr(kotlin, kotlin_name)
+        value = cast(object, getattr(kotlin, kotlin_name))
         # The binder declined to cache it -- a live property, read again on every access -- so this
         # layer does not freeze it either.
-        return _pythonic(value, name), kotlin_name in vars(kotlin)
+        return _pythonic(value), kotlin_name in cast(Mapping[str, object], vars(kotlin))
     if name[:1].isupper():
         try:
             nested = importlib.import_module(kotlin.__name__ + "." + name)
         except ImportError:
             return None
-        return KotlinObject(nested), True
+        return _kotlin_object(nested), True
     return None
 
 
 _STATIC_GETTER = "STATIC_GETTER"
 
 
-def _constant_groups(kotlin) -> dict:
+def _constant_groups(kotlin: types.ModuleType) -> dict[str, dict[str, str]]:
     """Group name -> {Pythonic constant name: Kotlin name}, for the Kotlin object [kotlin].
 
     A group is a type nested in the object, `P.G`, that some constant of `P` is declared as; it holds
@@ -337,12 +255,13 @@ def _constant_groups(kotlin) -> dict:
     """
     prefix = kotlin.__name__ + "."
     members = _name_table(kotlin)
-    groups: dict = {}
+    groups: dict[str, dict[str, str]] = {}
     for pythonic, kotlin_name in members.items():
         declared = _declared_type(kotlin, kotlin_name)
         if declared is None or declared[0] != _STATIC_GETTER or not declared[1]:
             continue
-        group = declared[1][len(prefix):] if declared[1].startswith(prefix) else ""
+        returns = declared[1]
+        group = returns[len(prefix):] if returns.startswith(prefix) else ""
         if not group[:1].isupper() or "." in group or group in members:
             continue
         groups.setdefault(group, {})[pythonic] = kotlin_name
@@ -360,17 +279,24 @@ class KotlinObject:
 
     __slots__ = ("_kotlin", "_cache", "_groups")
 
-    def __init__(self, kotlin_module):
+    _kotlin: types.ModuleType
+    _cache: dict[str, object]
+    _groups: dict[str, dict[str, str]] | None
+
+    def __init__(self, kotlin_module: types.ModuleType) -> None:
         object.__setattr__(self, "_kotlin", kotlin_module)
-        object.__setattr__(self, "_cache", {})
+        object.__setattr__(self, "_cache", dict[str, object]())
         object.__setattr__(self, "_groups", None)
 
-    def _constant_groups(self) -> dict:
-        if self._groups is None:
-            object.__setattr__(self, "_groups", _constant_groups(self._kotlin))
-        return self._groups
+    def _constant_groups(self) -> dict[str, dict[str, str]]:
+        known = self._groups
+        if known is not None:
+            return known
+        groups = _constant_groups(self._kotlin)
+        object.__setattr__(self, "_groups", groups)
+        return groups
 
-    def __getattr__(self, name):
+    def __getattr__(self, name: str) -> object:
         if name.startswith("__") and name.endswith("__"):
             raise AttributeError(name)
         cached = self._cache.get(name)
@@ -384,22 +310,43 @@ class KotlinObject:
                     f"{self._kotlin.__name__} has nothing spelled {name!r} under pythonx's naming rule"
                 )
             # The grouping is metadata and is kept; the constants inside are read on each access.
-            resolved = ConstantGroup(self, f"{self._kotlin.__name__}.{name}", members), True
+            group = ConstantGroup(self, f"{self._kotlin.__name__}.{name}", members)
+            self._cache[name] = group
+            return group
         value, cacheable = resolved
         if cacheable:
             self._cache[name] = value
         return value
 
-    def __setattr__(self, name, value):
+    def __setattr__(self, name: str, value: object) -> None:
         raise AttributeError(f"{self._kotlin.__name__} is a Kotlin object; its members are read-only here")
 
-    def __dir__(self):
+    def __dir__(self) -> list[str]:
         return sorted(set(_name_table(self._kotlin)) | set(self._constant_groups()))
 
-    def __repr__(self):
+    def __repr__(self) -> str:
         return f"<pythonx view of Kotlin object {self._kotlin.__name__}>"
 
 
+class CallableKotlinObject(KotlinObject):
+    """A Kotlin object whose name is also a function in its package (`Color`), callable as that function.
+
+    The binder makes such a module callable (python-multiplatform #78): `Color(0xFFFFFFFF)` calls
+    the `Color` function, while `Color.Red` is still a constant of the object. Calling goes to the
+    binder's module itself, which resolves the function on every call.
+    """
+
+    __slots__ = ()
+
+    def __call__(self, *args: object, **kwargs: object) -> object:
+        return cast("Callable[..., object]", self._kotlin)(*args, **kwargs)
+
+
+def _kotlin_object(kotlin_module: types.ModuleType) -> KotlinObject:
+    """The namespace for a Kotlin object module: callable only when the binder made the module callable."""
+    return CallableKotlinObject(kotlin_module) if callable(kotlin_module) else KotlinObject(kotlin_module)
+
+
 class ConstantGroup:
     """The constants of a Kotlin object declared as one type nested in it: `Alignment.Horizontal`.
 
@@ -410,12 +357,16 @@ class ConstantGroup:
 
     __slots__ = ("_owner", "_kotlin_type", "_members")
 
-    def __init__(self, owner, kotlin_type, members):
+    _owner: KotlinObject
+    _kotlin_type: str
+    _members: dict[str, str]
+
+    def __init__(self, owner: KotlinObject, kotlin_type: str, members: Mapping[str, str]) -> None:
         object.__setattr__(self, "_owner", owner)
         object.__setattr__(self, "_kotlin_type", kotlin_type)
         object.__setattr__(self, "_members", dict(members))
 
-    def __getattr__(self, name):
+    def __getattr__(self, name: str) -> object:
         if name.startswith("__") and name.endswith("__"):
             raise AttributeError(name)
         if name not in self._members:
@@ -424,33 +375,36 @@ class ConstantGroup:
                 f"{self._owner._kotlin.__name__} declared as {self._kotlin_type}: "
                 + ", ".join(sorted(self._members))
             )
-        return getattr(self._owner, name)
+        # The owner's own resolver, by name: a constant is never an attribute of `KotlinObject` itself.
+        return self._owner.__getattr__(name)
 
-    def __setattr__(self, name, value):
+    def __setattr__(self, name: str, value: object) -> None:
         raise AttributeError(f"{self._kotlin_type} is a group of Kotlin constants; they are read-only here")
 
-    def __dir__(self):
+    def __dir__(self) -> list[str]:
         return sorted(self._members)
 
-    def __repr__(self):
+    def __repr__(self) -> str:
         return f"<pythonx group of {self._owner._kotlin.__name__} constants declared {self._kotlin_type}>"
 
 
-def _aliases(module_name: str) -> dict:
+def _aliases(module_name: str) -> dict[str, tuple[str, str]]:
     """Name -> `(source module, attribute path in it)`, per the manifest's `[aliases]`.
 
     An entry under a source module is a list of names (lent under the same name, path = the name) or
     a table `{ lent = "Path.To.Attr" }` (a different name, through an attribute path).
     """
-    borrowed = {}
+    borrowed: dict[str, tuple[str, str]] = {}
     for source, lent in manifest().get("aliases", {}).get(module_name, {}).items():
-        pairs = ((name, name) for name in lent) if isinstance(lent, list) else lent.items()
+        pairs: Iterable[tuple[str, str]] = (
+            ((name, name) for name in lent) if isinstance(lent, list) else lent.items()
+        )
         for name, path in pairs:
             borrowed[name] = (source, path)
     return borrowed
 
 
-def _borrow(module_name: str, name: str, source: str, path: str):
+def _borrow(module_name: str, name: str, source: str, path: str) -> object:
     """The value of the alias [name]: [path] read in [source].
 
     A bare name is resolved once and kept in the owner's namespace. A path with attribute steps is
@@ -458,22 +412,22 @@ def _borrow(module_name: str, name: str, source: str, path: str):
     serves `Icons.Default` afresh on every read and this layer does not freeze it either.
     """
     head, *rest = path.split(".")
-    value = getattr(importlib.import_module(source), head)
+    value = cast(object, getattr(importlib.import_module(source), head))
     for step in rest:
-        value = getattr(value, step)
+        value = cast(object, getattr(value, step))
     if not rest:
         setattr(sys.modules[module_name], name, value)
     return value
 
 
-def reexport(module_name: str):
+def reexport(module_name: str) -> tuple[Callable[[str], object], Callable[[], list[str]]]:
     """The module-level `__getattr__` and `__dir__` for the mapped package `module_name`.
 
     Nothing is resolved here, only when a name is first read, so importing a `pythonx.compose`
     module needs neither the manifest row's Kotlin package nor an installed binder.
     """
 
-    def __getattr__(name):
+    def __getattr__(name: str) -> object:
         if name.startswith("__") and name.endswith("__"):
             raise AttributeError(name)
         if importlib.util.find_spec(module_name + "." + name) is not None:
@@ -501,8 +455,8 @@ def reexport(module_name: str):
             setattr(sys.modules[module_name], name, value)
         return value
 
-    def __dir__():
-        own = set(vars(sys.modules[module_name])) | set(_aliases(module_name))
+    def __dir__() -> list[str]:
+        own = set(cast(Mapping[str, object], vars(sys.modules[module_name]))) | set(_aliases(module_name))
         try:
             own.update(_name_table(kotlin_module(module_name)))
         except (RuntimeError, ImportError):

pythonx/compose/foundation/__init__.pyi

@@ -1,4 +1,4 @@
-# GENERATED by scripts/gen_stubs.py from python-multiplatform's Kotlin-named stubs (artifact kotlin-stubs, workflow run 37103737430, commit a5028618, Compose 1.11.1). Do not edit.
+# GENERATED by scripts/gen_stubs.py from python-multiplatform's Kotlin-named stubs (artifact ks, workflow run 42402779166, commit 9507e6dd, Compose 1.11.1-ext.2). Do not edit.
 import typing as _t
 
 class BorderStroke:

pythonx/compose/foundation/layout/__init__.pyi

@@ -1,2 +1,2 @@
-# GENERATED by scripts/gen_stubs.py from python-multiplatform's Kotlin-named stubs (artifact kotlin-stubs, workflow run 37103737430, commit a5028618, Compose 1.11.1). Do not edit.
+# GENERATED by scripts/gen_stubs.py from python-multiplatform's Kotlin-named stubs (artifact ks, workflow run 42402779166, commit 9507e6dd, Compose 1.11.1-ext.2). Do not edit.
 from pythonx.compose.layout import *

pythonx/compose/foundation/text/input/__init__.pyi

@@ -1,4 +1,4 @@
-# GENERATED by scripts/gen_stubs.py from python-multiplatform's Kotlin-named stubs (artifact kotlin-stubs, workflow run 37103737430, commit a5028618, Compose 1.11.1). Do not edit.
+# GENERATED by scripts/gen_stubs.py from python-multiplatform's Kotlin-named stubs (artifact ks, workflow run 42402779166, commit 9507e6dd, Compose 1.11.1-ext.2). Do not edit.
 import typing as _t
 
 class _TextFieldState_clearText(_t.Protocol):
@@ -25,18 +25,24 @@ class OutputTransformation:
 class TextFieldBuffer:
     """Kotlin: androidx.compose.foundation.text.input.TextFieldBuffer"""
 
+class TextFieldDecorator:
+    """Kotlin: androidx.compose.foundation.text.input.TextFieldDecorator"""
+
 class TextFieldLineLimits:
     """Kotlin: androidx.compose.foundation.text.input.TextFieldLineLimits"""
 
 class TextFieldState:
     """Kotlin: androidx.compose.foundation.text.input.TextFieldState"""
-    def __init__(self, initialText: str = ..., initialSelection: _t.Any = ...) -> None:
+    def __init__(self, initial_text: str = ..., initial_selection: _t.Any = ...) -> None:
         """Kotlin constructor: androidx.compose.foundation.text.input.TextFieldState (androidx.compose.foundation.text.input.TextFieldState(initialText: kotlin.String, initialSelection: androidx.compose.ui.text.TextRange): androidx.compose.foundation.text.input.TextFieldState)"""
         ...
     clear_text: _t.ClassVar[_TextFieldState_clearText]
     set_text_and_place_cursor_at_end: _t.ClassVar[_TextFieldState_setTextAndPlaceCursorAtEnd]
     set_text_and_select_all: _t.ClassVar[_TextFieldState_setTextAndSelectAll]
     to_text_field_buffer: _t.ClassVar[_TextFieldState_toTextFieldBuffer]
+    def edit(self, block: _t.Callable[[TextFieldBuffer], None]) -> None:
+        """Kotlin member: androidx.compose.foundation.text.input.TextFieldState.edit"""
+        ...
     @property
     def composition(self) -> _t.Any | None:
         """Kotlin property: androidx.compose.foundation.text.input.TextFieldState.composition (androidx.compose.foundation.text.input.TextFieldState.composition: androidx.compose.ui.text.TextRange?)"""