pythonnative 0.4.0__tar.gz → 0.6.0__tar.gz

{pythonnative-0.4.0/src/pythonnative.egg-info → pythonnative-0.6.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pythonnative
-Version: 0.4.0
+Version: 0.6.0
 Summary: Cross-platform native UI toolkit for Android and iOS
 Author: Owen Carey
 License: MIT License
@@ -34,12 +34,11 @@ Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3 :: Only
-Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Topic :: Software Development :: User Interfaces
-Requires-Python: >=3.9
+Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: requests>=2.31.0
@@ -89,18 +88,17 @@ Dynamic: license-file
 
 ## Overview
 
-PythonNative is a cross-platform toolkit for building native Android and iOS apps in Python. It provides a Pythonic API for native UI components, lifecycle events, and device capabilities, powered by Chaquopy on Android and rubicon-objc on iOS. Write your app once in Python and run it on both platforms with genuinely native interfaces.
+PythonNative is a cross-platform toolkit for building native Android and iOS apps in Python. It provides a **declarative, React-like component model** with automatic reconciliation, powered by Chaquopy on Android and rubicon-objc on iOS. Describe your UI as a tree of elements, manage state with `set_state()`, and let PythonNative handle creating and updating native views.
 
 ## Features
 
-- **Cross-platform native UI:** Build Android and iOS apps from a single Python codebase with truly native rendering.
+- **Declarative UI:** Describe *what* your UI should look like with element functions (`Text`, `Button`, `Column`, `Row`, etc.). PythonNative creates and updates native views automatically.
+- **Reactive state:** Call `self.set_state(key=value)` and the framework re-renders only what changed — no manual view mutation.
+- **Virtual view tree + reconciler:** Element trees are diffed and patched with minimal native mutations, similar to React's reconciliation.
 - **Direct native bindings:** Python calls platform APIs directly through Chaquopy and rubicon-objc, with no JavaScript bridge.
-- **Unified component API:** Components like `Page`, `StackView`, `Label`, `Button`, and `WebView` share a consistent interface across platforms.
-- **CLI scaffolding:** `pn init` creates a ready-to-run project structure; `pn run android` and `pn run ios` build and launch your app.
-- **Page lifecycle:** Hooks for `on_create`, `on_start`, `on_resume`, `on_pause`, `on_stop`, and `on_destroy`, with state save and restore.
+- **CLI scaffolding:** `pn init` creates a ready-to-run project; `pn run android` and `pn run ios` build and launch your app.
 - **Navigation:** Push and pop screens with argument passing for multi-page apps.
-- **Rich component set:** Core views (Label, Button, TextField, ImageView, WebView, Switch, DatePicker, and more) plus Material Design variants.
-- **Bundled templates:** Android Gradle and iOS Xcode templates are included, so scaffolding requires no network access.
+- **Bundled templates:** Android Gradle and iOS Xcode templates are included — scaffolding requires no network access.
 
 ## Quick Start
 
@@ -119,15 +117,18 @@ import pythonnative as pn
 class MainPage(pn.Page):
     def __init__(self, native_instance):
         super().__init__(native_instance)
-
-    def on_create(self):
-        super().on_create()
-        stack = pn.StackView()
-        stack.add_view(pn.Label("Hello from PythonNative!"))
-        button = pn.Button("Tap me")
-        button.set_on_click(lambda: print("Button tapped"))
-        stack.add_view(button)
-        self.set_root_view(stack)
+        self.state = {"count": 0}
+
+    def render(self):
+        return pn.Column(
+            pn.Text(f"Count: {self.state['count']}", font_size=24),
+            pn.Button(
+                "Tap me",
+                on_click=lambda: self.set_state(count=self.state["count"] + 1),
+            ),
+            spacing=12,
+            padding=16,
+        )
 ```
 
 ## Documentation

{pythonnative-0.4.0 → pythonnative-0.6.0}/README.md

@@ -26,18 +26,17 @@
 
 ## Overview
 
-PythonNative is a cross-platform toolkit for building native Android and iOS apps in Python. It provides a Pythonic API for native UI components, lifecycle events, and device capabilities, powered by Chaquopy on Android and rubicon-objc on iOS. Write your app once in Python and run it on both platforms with genuinely native interfaces.
+PythonNative is a cross-platform toolkit for building native Android and iOS apps in Python. It provides a **declarative, React-like component model** with automatic reconciliation, powered by Chaquopy on Android and rubicon-objc on iOS. Describe your UI as a tree of elements, manage state with `set_state()`, and let PythonNative handle creating and updating native views.
 
 ## Features
 
-- **Cross-platform native UI:** Build Android and iOS apps from a single Python codebase with truly native rendering.
+- **Declarative UI:** Describe *what* your UI should look like with element functions (`Text`, `Button`, `Column`, `Row`, etc.). PythonNative creates and updates native views automatically.
+- **Reactive state:** Call `self.set_state(key=value)` and the framework re-renders only what changed — no manual view mutation.
+- **Virtual view tree + reconciler:** Element trees are diffed and patched with minimal native mutations, similar to React's reconciliation.
 - **Direct native bindings:** Python calls platform APIs directly through Chaquopy and rubicon-objc, with no JavaScript bridge.
-- **Unified component API:** Components like `Page`, `StackView`, `Label`, `Button`, and `WebView` share a consistent interface across platforms.
-- **CLI scaffolding:** `pn init` creates a ready-to-run project structure; `pn run android` and `pn run ios` build and launch your app.
-- **Page lifecycle:** Hooks for `on_create`, `on_start`, `on_resume`, `on_pause`, `on_stop`, and `on_destroy`, with state save and restore.
+- **CLI scaffolding:** `pn init` creates a ready-to-run project; `pn run android` and `pn run ios` build and launch your app.
 - **Navigation:** Push and pop screens with argument passing for multi-page apps.
-- **Rich component set:** Core views (Label, Button, TextField, ImageView, WebView, Switch, DatePicker, and more) plus Material Design variants.
-- **Bundled templates:** Android Gradle and iOS Xcode templates are included, so scaffolding requires no network access.
+- **Bundled templates:** Android Gradle and iOS Xcode templates are included — scaffolding requires no network access.
 
 ## Quick Start
 
@@ -56,15 +55,18 @@ import pythonnative as pn
 class MainPage(pn.Page):
     def __init__(self, native_instance):
         super().__init__(native_instance)
-
-    def on_create(self):
-        super().on_create()
-        stack = pn.StackView()
-        stack.add_view(pn.Label("Hello from PythonNative!"))
-        button = pn.Button("Tap me")
-        button.set_on_click(lambda: print("Button tapped"))
-        stack.add_view(button)
-        self.set_root_view(stack)
+        self.state = {"count": 0}
+
+    def render(self):
+        return pn.Column(
+            pn.Text(f"Count: {self.state['count']}", font_size=24),
+            pn.Button(
+                "Tap me",
+                on_click=lambda: self.set_state(count=self.state["count"] + 1),
+            ),
+            spacing=12,
+            padding=16,
+        )
 ```
 
 ## Documentation

{pythonnative-0.4.0 → pythonnative-0.6.0}/pyproject.toml

@@ -4,13 +4,13 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "pythonnative"
-version = "0.4.0"
+version = "0.6.0"
 description = "Cross-platform native UI toolkit for Android and iOS"
 authors = [
   { name = "Owen Carey" }
 ]
 readme = "README.md"
-requires-python = ">=3.9"
+requires-python = ">=3.10"
 license = { file = "LICENSE" }
 classifiers = [
   "Development Status :: 2 - Pre-Alpha",
@@ -18,7 +18,6 @@ classifiers = [
   "License :: OSI Approved :: MIT License",
   "Programming Language :: Python :: 3",
   "Programming Language :: Python :: 3 :: Only",
-  "Programming Language :: Python :: 3.9",
   "Programming Language :: Python :: 3.10",
   "Programming Language :: Python :: 3.11",
   "Programming Language :: Python :: 3.12",

pythonnative-0.6.0/src/pythonnative/__init__.py

@@ -0,0 +1,102 @@
+"""PythonNative — declarative native UI for Android and iOS.
+
+Public API::
+
+    import pythonnative as pn
+
+    @pn.component
+    def counter(initial=0):
+        count, set_count = pn.use_state(initial)
+        return pn.Column(
+            pn.Text(f"Count: {count}", font_size=24),
+            pn.Button("+", on_click=lambda: set_count(count + 1)),
+            spacing=12,
+        )
+
+    class MainPage(pn.Page):
+        def __init__(self, native_instance):
+            super().__init__(native_instance)
+
+        def render(self):
+            return pn.Column(
+                counter(initial=0),
+                counter(initial=10),
+                spacing=16,
+                padding=16,
+            )
+"""
+
+__version__ = "0.6.0"
+
+from .components import (
+    ActivityIndicator,
+    Button,
+    Column,
+    FlatList,
+    Image,
+    Modal,
+    Pressable,
+    ProgressBar,
+    Row,
+    SafeAreaView,
+    ScrollView,
+    Slider,
+    Spacer,
+    Switch,
+    Text,
+    TextInput,
+    View,
+    WebView,
+)
+from .element import Element
+from .hooks import (
+    Provider,
+    component,
+    create_context,
+    use_callback,
+    use_context,
+    use_effect,
+    use_memo,
+    use_ref,
+    use_state,
+)
+from .page import Page
+from .style import StyleSheet, ThemeContext
+
+__all__ = [
+    # Components
+    "ActivityIndicator",
+    "Button",
+    "Column",
+    "FlatList",
+    "Image",
+    "Modal",
+    "Pressable",
+    "ProgressBar",
+    "Row",
+    "SafeAreaView",
+    "ScrollView",
+    "Slider",
+    "Spacer",
+    "Switch",
+    "Text",
+    "TextInput",
+    "View",
+    "WebView",
+    # Core
+    "Element",
+    "Page",
+    # Hooks
+    "component",
+    "create_context",
+    "use_callback",
+    "use_context",
+    "use_effect",
+    "use_memo",
+    "use_ref",
+    "use_state",
+    "Provider",
+    # Styling
+    "StyleSheet",
+    "ThemeContext",
+]

{pythonnative-0.4.0 → pythonnative-0.6.0}/src/pythonnative/cli/pn.py

@@ -2,6 +2,7 @@ import argparse
 import hashlib
 import json
 import os
+import re
 import shutil
 import subprocess
 import sys
@@ -41,49 +42,49 @@ def init_project(args: argparse.Namespace) -> None:
 
     os.makedirs(app_dir, exist_ok=True)
 
-    # Minimal hello world app scaffold (no bootstrap function; host instantiates Page directly)
     main_page_py = os.path.join(app_dir, "main_page.py")
     if not os.path.exists(main_page_py) or args.force:
         with open(main_page_py, "w", encoding="utf-8") as f:
-            f.write(
-                """import pythonnative as pn
+            f.write("""import pythonnative as pn
 
 
 class MainPage(pn.Page):
     def __init__(self, native_instance):
         super().__init__(native_instance)
-
-    def on_create(self):
-        super().on_create()
-        stack = (
-            pn.StackView()
-            .set_axis("vertical")
-            .set_spacing(12)
-            .set_alignment("fill")
-            .set_padding(all=16)
-        )
-        stack.add_view(pn.Label("Hello from PythonNative!").set_text_size(18))
-        button = pn.Button("Tap me").set_on_click(lambda: print("Button clicked"))
-        stack.add_view(button)
-        self.set_root_view(stack.wrap_in_scroll())
-"""
+        self.state = {"count": 0}
+
+    def increment(self):
+        self.set_state(count=self.state["count"] + 1)
+
+    def render(self):
+        return pn.ScrollView(
+            pn.Column(
+                pn.Text("Hello from PythonNative!", font_size=24, bold=True),
+                pn.Text(f"Tapped {self.state['count']} times"),
+                pn.Button("Tap me", on_click=self.increment),
+                spacing=12,
+                padding=16,
+                alignment="fill",
             )
+        )
+""")
 
     # Create config
     config = {
         "name": project_name,
         "appId": "com.example." + project_name.replace(" ", "").lower(),
         "entryPoint": "app/main_page.py",
+        "pythonVersion": "3.11",
         "ios": {},
         "android": {},
     }
     with open(config_path, "w", encoding="utf-8") as f:
         json.dump(config, f, indent=2)
 
-    # Requirements
+    # Requirements (third-party packages only; pythonnative itself is bundled by the CLI)
     if not os.path.exists(requirements_path) or args.force:
         with open(requirements_path, "w", encoding="utf-8") as f:
-            f.write("pythonnative\n")
+            f.write("")
 
     # .gitignore
     default_gitignore = "# PythonNative\n" "__pycache__/\n" "*.pyc\n" ".venv/\n" "build/\n" ".DS_Store\n"
@@ -157,7 +158,11 @@ def _copy_bundled_template_dir(template_dir: str, destination: str) -> None:
 
 
 def _github_json(url: str) -> Any:
-    req = urllib.request.Request(url, headers={"User-Agent": "pythonnative-cli"})
+    headers: dict[str, str] = {"User-Agent": "pythonnative-cli"}
+    token = os.environ.get("GITHUB_TOKEN") or os.environ.get("GH_TOKEN")
+    if token:
+        headers["Authorization"] = f"Bearer {token}"
+    req = urllib.request.Request(url, headers=headers)
     with urllib.request.urlopen(req) as r:
         return json.loads(r.read().decode("utf-8"))
 
@@ -212,6 +217,43 @@ def create_ios_project(project_name: str, destination: str) -> None:
     _copy_bundled_template_dir("ios_template", destination)
 
 
+def _read_project_config() -> dict:
+    """Read pythonnative.json from the current working directory."""
+    config_path = os.path.join(os.getcwd(), "pythonnative.json")
+    if os.path.exists(config_path):
+        with open(config_path, encoding="utf-8") as f:
+            return json.load(f)
+    return {}
+
+
+def _read_requirements(requirements_path: str) -> list[str]:
+    """Read a requirements file and return non-empty, non-comment lines.
+
+    Exits with an error if pythonnative is listed — the CLI bundles it
+    directly, so it must not be installed separately via pip/Chaquopy.
+    """
+    if not os.path.exists(requirements_path):
+        return []
+    with open(requirements_path, encoding="utf-8") as f:
+        lines = f.readlines()
+    result: list[str] = []
+    for line in lines:
+        stripped = line.strip()
+        if not stripped or stripped.startswith("#") or stripped.startswith("-"):
+            continue
+        pkg_name = re.split(r"[\[><=!;]", stripped)[0].strip()
+        if pkg_name.lower().replace("-", "_") == "pythonnative":
+            print(
+                "Error: 'pythonnative' must not be in requirements.txt.\n"
+                "The pn CLI automatically bundles the installed pythonnative into your app.\n"
+                "requirements.txt is for third-party packages only (e.g. humanize, requests).\n"
+                "Remove the pythonnative line from requirements.txt and try again."
+            )
+            sys.exit(1)
+        result.append(stripped)
+    return result
+
+
 def run_project(args: argparse.Namespace) -> None:
     """
     Run the specified project.
@@ -219,9 +261,15 @@ def run_project(args: argparse.Namespace) -> None:
     # Determine the platform
     platform: str = args.platform
     prepare_only: bool = getattr(args, "prepare_only", False)
+    hot_reload: bool = getattr(args, "hot_reload", False)
+
+    # Read project configuration and save project root before any chdir
+    project_dir: str = os.getcwd()
+    config = _read_project_config()
+    python_version: str = config.get("pythonVersion", "3.11")
 
     # Define the build directory
-    build_dir: str = os.path.join(os.getcwd(), "build", platform)
+    build_dir: str = os.path.join(project_dir, "build", platform)
 
     # Create the build directory if it doesn't exist
     os.makedirs(build_dir, exist_ok=True)
@@ -265,10 +313,30 @@ def run_project(args: argparse.Namespace) -> None:
         # Non-fatal; fallback to the packaged PyPI dependency if present
         pass
 
-    # Install any necessary Python packages into the project environment
+    # Validate and read the user's requirements.txt
+    requirements_path = os.path.join(project_dir, "requirements.txt")
+    pip_reqs = _read_requirements(requirements_path)
+
+    if platform == "android":
+        # Patch the Android build.gradle with the configured Python version
+        app_build_gradle = os.path.join(build_dir, "android_template", "app", "build.gradle")
+        if os.path.exists(app_build_gradle):
+            with open(app_build_gradle, encoding="utf-8") as f:
+                content = f.read()
+            content = content.replace('version "3.11"', f'version "{python_version}"')
+            with open(app_build_gradle, "w", encoding="utf-8") as f:
+                f.write(content)
+        # Copy requirements.txt into the Android project for Chaquopy
+        android_reqs_path = os.path.join(build_dir, "android_template", "app", "requirements.txt")
+        if os.path.exists(requirements_path):
+            shutil.copy2(requirements_path, android_reqs_path)
+        else:
+            with open(android_reqs_path, "w", encoding="utf-8") as f:
+                f.write("")
+
+    # Install any necessary Python packages into the host environment
     # Skip installation during prepare-only to avoid network access and speed up scaffolding
     if not prepare_only:
-        requirements_path = os.path.join(os.getcwd(), "requirements.txt")
         if os.path.exists(requirements_path):
             subprocess.run([sys.executable, "-m", "pip", "install", "-r", requirements_path], check=False)
 
@@ -520,6 +588,29 @@ def run_project(args: argparse.Namespace) -> None:
                 except Exception:
                     # Non-fatal; if metadata isn't present, rubicon import may fail and fallback UI will appear
                     pass
+                # Install user's pip requirements (pure-Python packages) into the app bundle
+                if pip_reqs:
+                    try:
+                        reqs_tmp = os.path.join(build_dir, "ios_requirements.txt")
+                        with open(reqs_tmp, "w", encoding="utf-8") as f:
+                            f.write("\n".join(pip_reqs) + "\n")
+                        tmp_reqs_dir = os.path.join(build_dir, "ios_user_packages")
+                        if os.path.isdir(tmp_reqs_dir):
+                            shutil.rmtree(tmp_reqs_dir)
+                        os.makedirs(tmp_reqs_dir, exist_ok=True)
+                        subprocess.run(
+                            [sys.executable, "-m", "pip", "install", "-t", tmp_reqs_dir, "-r", reqs_tmp],
+                            check=False,
+                        )
+                        for entry in os.listdir(tmp_reqs_dir):
+                            src_entry = os.path.join(tmp_reqs_dir, entry)
+                            dst_entry = os.path.join(platform_site_dir, entry)
+                            if os.path.isdir(src_entry):
+                                shutil.copytree(src_entry, dst_entry, dirs_exist_ok=True)
+                            else:
+                                shutil.copy2(src_entry, dst_entry)
+                    except Exception:
+                        pass
                 # Note: Python.xcframework provides a static library for Simulator; it must be linked at build time.
                 # We copy the XCFramework into the project directory above so Xcode can link it.
             except Exception:
@@ -566,6 +657,39 @@ def run_project(args: argparse.Namespace) -> None:
             except Exception:
                 print("Failed to auto-run on Simulator; open the project in Xcode to run.")
 
+    # Hot-reload file watcher
+    if hot_reload and not prepare_only:
+        _run_hot_reload(platform, project_dir, build_dir)
+
+
+def _run_hot_reload(platform: str, project_dir: str, build_dir: str) -> None:
+    """Watch ``app/`` for changes and push updated files to the device."""
+    from .hot_reload import FileWatcher
+
+    app_dir = os.path.join(project_dir, "app")
+
+    def on_change(changed_files: List[str]) -> None:
+        for fpath in changed_files:
+            rel = os.path.relpath(fpath, project_dir)
+            print(f"[hot-reload] Changed: {rel}")
+            if platform == "android":
+                dest = f"/data/data/com.pythonnative.android_template/files/{rel}"
+                subprocess.run(["adb", "push", fpath, dest], check=False, capture_output=True)
+            elif platform == "ios":
+                pass  # simctl file push would go here
+
+    print("[hot-reload] Watching app/ for changes. Press Ctrl+C to stop.")
+    watcher = FileWatcher(app_dir, on_change, interval=1.0)
+    watcher.start()
+    try:
+        import time
+
+        while True:
+            time.sleep(1)
+    except KeyboardInterrupt:
+        watcher.stop()
+        print("\n[hot-reload] Stopped.")
+
 
 def clean_project(args: argparse.Namespace) -> None:
     """
@@ -600,6 +724,11 @@ def main() -> None:
         action="store_true",
         help="Extract templates and stage app without building",
     )
+    parser_run.add_argument(
+        "--hot-reload",
+        action="store_true",
+        help="Watch app/ for changes and push updates to the running app",
+    )
     parser_run.set_defaults(func=run_project)
 
     # Create a new command 'clean' that calls clean_project