pythonnative 0.4.0__py3-none-any.whl → 0.6.0__py3-none-any.whl

pythonnative/__init__.py

@@ -1,74 +1,102 @@
-from importlib import import_module
-from typing import Any, Dict
+"""PythonNative — declarative native UI for Android and iOS.
 
-__version__ = "0.4.0"
+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__ = [
-    "ActivityIndicatorView",
+    # Components
+    "ActivityIndicator",
     "Button",
-    "DatePicker",
-    "ImageView",
-    "Label",
-    "ListView",
-    "MaterialActivityIndicatorView",
-    "MaterialButton",
-    "MaterialDatePicker",
-    "MaterialProgressView",
-    "MaterialSearchBar",
-    "MaterialSwitch",
-    "MaterialTimePicker",
-    "MaterialBottomNavigationView",
-    "MaterialToolbar",
-    "Page",
-    "PickerView",
-    "ProgressView",
+    "Column",
+    "FlatList",
+    "Image",
+    "Modal",
+    "Pressable",
+    "ProgressBar",
+    "Row",
+    "SafeAreaView",
     "ScrollView",
-    "SearchBar",
-    "StackView",
+    "Slider",
+    "Spacer",
     "Switch",
-    "TextField",
-    "TextView",
-    "TimePicker",
+    "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",
 ]
-
-_NAME_TO_MODULE: Dict[str, str] = {
-    "ActivityIndicatorView": ".activity_indicator_view",
-    "Button": ".button",
-    "DatePicker": ".date_picker",
-    "ImageView": ".image_view",
-    "Label": ".label",
-    "ListView": ".list_view",
-    "MaterialActivityIndicatorView": ".material_activity_indicator_view",
-    "MaterialButton": ".material_button",
-    "MaterialDatePicker": ".material_date_picker",
-    "MaterialProgressView": ".material_progress_view",
-    "MaterialSearchBar": ".material_search_bar",
-    "MaterialSwitch": ".material_switch",
-    "MaterialTimePicker": ".material_time_picker",
-    "MaterialBottomNavigationView": ".material_bottom_navigation_view",
-    "MaterialToolbar": ".material_toolbar",
-    "Page": ".page",
-    "PickerView": ".picker_view",
-    "ProgressView": ".progress_view",
-    "ScrollView": ".scroll_view",
-    "SearchBar": ".search_bar",
-    "StackView": ".stack_view",
-    "Switch": ".switch",
-    "TextField": ".text_field",
-    "TextView": ".text_view",
-    "TimePicker": ".time_picker",
-    "WebView": ".web_view",
-}
-
-
-def __getattr__(name: str) -> Any:
-    module_path = _NAME_TO_MODULE.get(name)
-    if not module_path:
-        raise AttributeError(f"module 'pythonnative' has no attribute {name!r}")
-    module = import_module(module_path, package=__name__)
-    return getattr(module, name)
-
-
-def __dir__() -> Any:
-    return sorted(list(globals().keys()) + __all__)

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