pythonnative 0.8.0__py3-none-any.whl → 0.9.0__py3-none-any.whl

pythonnative/__init__.py

@@ -14,7 +14,7 @@ Public API::
         )
 """
 
-__version__ = "0.8.0"
+__version__ = "0.9.0"
 
 from .components import (
     ActivityIndicator,

pythonnative/_ios_log.py

@@ -0,0 +1,94 @@
+"""Route Python ``sys.stdout``/``sys.stderr`` through fd 2 on iOS.
+
+Why
+---
+When an app is launched via ``xcrun simctl launch --console-pty`` (what
+``pn run ios`` does), the simulator attaches the caller's terminal to
+the app's stderr, which is the same channel ``NSLog`` / ``os_log``
+writes to. Python ``print()`` calls, however, go to ``sys.stdout``
+(fd 1), and for reasons specific to how CPython's embedded framework
+is started on the iOS Simulator that descriptor does not reach the
+attached console. As a result users see Swift-side ``NSLog`` output
+but never their own ``print()`` output.
+
+Redirecting ``sys.stdout`` / ``sys.stderr`` at a Python level to write
+straight to fd 2 is a small, reliable fix: fd 2 *is* visible to
+``simctl`` (that's exactly how ``NSLog`` reaches the terminal), so
+Python output lands next to the Swift logs with correct ordering.
+
+This module is intentionally self-contained: no rubicon-objc or
+platform-specific C bindings required, so it's safe to import early
+during ``pythonnative`` package initialization.
+"""
+
+from __future__ import annotations
+
+import os
+import sys
+from typing import Iterable
+
+_STDERR_FD = 2
+
+
+class _StderrStream:
+    """Minimal text-mode file-like that writes UTF-8 bytes to fd 2.
+
+    It's write-through (no buffering) so a ``print()`` call appears in
+    the terminal immediately, which matches user expectations for an
+    interactive "run on simulator" log stream.
+    """
+
+    encoding = "utf-8"
+    errors = "replace"
+    mode = "w"
+    name = "<stderr>"
+
+    def write(self, s: str) -> int:
+        if not s:
+            return 0
+        data = s.encode(self.encoding, self.errors)
+        try:
+            return os.write(_STDERR_FD, data)
+        except OSError:
+            return 0
+
+    def writelines(self, lines: Iterable[str]) -> None:
+        for line in lines:
+            self.write(line)
+
+    def flush(self) -> None:
+        # os.write is unbuffered; nothing to flush.
+        return None
+
+    def isatty(self) -> bool:
+        try:
+            return os.isatty(_STDERR_FD)
+        except OSError:
+            return False
+
+    def fileno(self) -> int:
+        return _STDERR_FD
+
+    def close(self) -> None:
+        # Don't actually close fd 2.
+        return None
+
+    @property
+    def closed(self) -> bool:
+        return False
+
+
+_installed = False
+
+
+def install() -> None:
+    """Swap ``sys.stdout`` / ``sys.stderr`` for fd-2 writers.
+
+    Safe to call multiple times; only the first call has effect.
+    """
+    global _installed
+    if _installed:
+        return
+    sys.stdout = _StderrStream()
+    sys.stderr = _StderrStream()
+    _installed = True

pythonnative/cli/pn.py

@@ -246,6 +246,55 @@ def _read_requirements(requirements_path: str) -> list[str]:
     return result
 
 
+ANDROID_LOGCAT_FILTERS: list[str] = [
+    "python.stdout:V",
+    "python.stderr:V",
+    "MainActivity:V",
+    "PageFragment:V",
+    "Navigator:V",
+    "PythonNative:V",
+    "AndroidRuntime:E",
+    "System.err:W",
+    "*:S",
+]
+
+IOS_BUNDLE_ID: str = "com.pythonnative.ios-template"
+
+
+def _start_android_log_stream() -> Optional[subprocess.Popen]:
+    """Clear logcat and stream Python-relevant log tags to the terminal.
+
+    Returns the ``adb logcat`` subprocess, or ``None`` when ``adb`` is
+    unavailable. Python's ``print()`` output reaches logcat via Chaquopy,
+    which redirects ``sys.stdout``/``sys.stderr`` to the ``python.stdout``
+    and ``python.stderr`` tags.
+    """
+    try:
+        subprocess.run(["adb", "logcat", "-c"], check=False, capture_output=True)
+    except FileNotFoundError:
+        print("Note: 'adb' not found on PATH; skipping log streaming.")
+        return None
+    try:
+        proc = subprocess.Popen(["adb", "logcat", *ANDROID_LOGCAT_FILTERS])
+    except FileNotFoundError:
+        return None
+    print("Streaming Python logs from device (Ctrl+C to stop)...")
+    return proc
+
+
+def _terminate_subprocess(proc: Optional[subprocess.Popen]) -> None:
+    """Politely stop a subprocess, escalating to SIGKILL if needed."""
+    if proc is None:
+        return
+    if proc.poll() is not None:
+        return
+    proc.terminate()
+    try:
+        proc.wait(timeout=3)
+    except subprocess.TimeoutExpired:
+        proc.kill()
+
+
 def run_project(args: argparse.Namespace) -> None:
     """
     Run the specified project.
@@ -254,6 +303,7 @@ def run_project(args: argparse.Namespace) -> None:
     platform: str = args.platform
     prepare_only: bool = getattr(args, "prepare_only", False)
     hot_reload: bool = getattr(args, "hot_reload", False)
+    show_logs: bool = not getattr(args, "no_logs", False)
 
     # Read project configuration and save project root before any chdir
     project_dir: str = os.getcwd()
@@ -371,6 +421,18 @@ def run_project(args: argparse.Namespace) -> None:
             ],
             check=True,
         )
+
+        # Stream Python logs from logcat unless the user opted out or requested
+        # hot-reload (hot-reload handles its own log tailing below).
+        if show_logs and not hot_reload:
+            logcat_proc = _start_android_log_stream()
+            if logcat_proc is not None:
+                try:
+                    logcat_proc.wait()
+                except KeyboardInterrupt:
+                    print()
+                    _terminate_subprocess(logcat_proc)
+                    print("Stopped log streaming.")
     elif platform == "ios":
         # Attempt to build and run on iOS Simulator (best-effort)
         ios_project_dir: str = os.path.join(build_dir, "ios_template")
@@ -640,22 +702,64 @@ def run_project(args: argparse.Namespace) -> None:
                     return
 
                 udid = preferred.get("udid")
-                # Boot (no-op if already booted)
-                subprocess.run(["xcrun", "simctl", "boot", udid], check=False)
-                # Install and launch
+                # Boot (no-op if already booted). simctl returns non-zero and
+                # prints to stderr when the device is already Booted; we
+                # don't care about that case, so swallow its output.
+                subprocess.run(["xcrun", "simctl", "boot", udid], check=False, capture_output=True)
+                # Install
                 subprocess.run(["xcrun", "simctl", "install", udid, app_path], check=False)
-                subprocess.run(["xcrun", "simctl", "launch", udid, "com.pythonnative.ios-template"], check=False)
-                print("Launched iOS app on Simulator (best-effort).")
+                if show_logs and not hot_reload:
+                    # Attach the app's stdout/stderr to this terminal so Python
+                    # print() calls and exceptions are visible. SIMCTL_CHILD_*
+                    # env vars are forwarded to the launched process.
+                    sim_env = os.environ.copy()
+                    sim_env["SIMCTL_CHILD_PYTHONUNBUFFERED"] = "1"
+                    print("Launched iOS app on Simulator. Streaming logs (Ctrl+C to stop)...")
+                    try:
+                        subprocess.run(
+                            [
+                                "xcrun",
+                                "simctl",
+                                "launch",
+                                "--console-pty",
+                                "--terminate-running-process",
+                                udid,
+                                IOS_BUNDLE_ID,
+                            ],
+                            env=sim_env,
+                            check=False,
+                        )
+                    except KeyboardInterrupt:
+                        print()
+                        subprocess.run(
+                            ["xcrun", "simctl", "terminate", udid, IOS_BUNDLE_ID],
+                            check=False,
+                            capture_output=True,
+                        )
+                        print("Stopped log streaming.")
+                else:
+                    subprocess.run(["xcrun", "simctl", "launch", udid, IOS_BUNDLE_ID], check=False)
+                    print("Launched iOS app on Simulator (best-effort).")
+                    if show_logs and hot_reload:
+                        print(
+                            "Note: live Python log streaming on iOS is disabled while --hot-reload is active; "
+                            "use Console.app or Xcode to view logs."
+                        )
             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)
+        _run_hot_reload(platform, project_dir, build_dir, show_logs=show_logs)
+
 
+def _run_hot_reload(platform: str, project_dir: str, build_dir: str, show_logs: bool = True) -> None:
+    """Watch ``app/`` for changes and push updated files to the device.
 
-def _run_hot_reload(platform: str, project_dir: str, build_dir: str) -> None:
-    """Watch ``app/`` for changes and push updated files to the device."""
+    When ``show_logs`` is true and targeting Android, ``adb logcat`` is
+    streamed in parallel so Python print/exception output stays visible
+    alongside hot-reload notifications.
+    """
     from .hot_reload import FileWatcher
 
     app_dir = os.path.join(project_dir, "app")
@@ -673,12 +777,23 @@ def _run_hot_reload(platform: str, project_dir: str, build_dir: str) -> None:
     print("[hot-reload] Watching app/ for changes. Press Ctrl+C to stop.")
     watcher = FileWatcher(app_dir, on_change, interval=1.0)
     watcher.start()
+
+    logcat_proc: Optional[subprocess.Popen] = None
+    if show_logs and platform == "android":
+        logcat_proc = _start_android_log_stream()
+
     try:
-        import time
+        if logcat_proc is not None:
+            logcat_proc.wait()
+        else:
+            import time
 
-        while True:
-            time.sleep(1)
+            while True:
+                time.sleep(1)
     except KeyboardInterrupt:
+        pass
+    finally:
+        _terminate_subprocess(logcat_proc)
         watcher.stop()
         print("\n[hot-reload] Stopped.")
 
@@ -721,6 +836,11 @@ def main() -> None:
         action="store_true",
         help="Watch app/ for changes and push updates to the running app",
     )
+    parser_run.add_argument(
+        "--no-logs",
+        action="store_true",
+        help="Don't attach to the app's stdout/stderr after launching (default: stream logs)",
+    )
     parser_run.set_defaults(func=run_project)
 
     # Create a new command 'clean' that calls clean_project

pythonnative/page.py

@@ -27,7 +27,7 @@ import importlib
 import json
 from typing import Any, Dict, Optional
 
-from .utils import IS_ANDROID, set_android_context
+from .utils import IS_ANDROID, IS_IOS, set_android_context
 
 _MAX_RENDER_PASSES = 25
 
@@ -250,6 +250,21 @@ else:
     except ImportError:
         pass
 
+    # Redirect Python's stdout/stderr through fd 2 so ``print()`` output is
+    # visible via ``xcrun simctl launch --console-pty``. This runs at
+    # ``pythonnative.page`` import time, i.e. before any user page module
+    # (e.g. ``app.main_page``) is imported, so their top-level ``print()``
+    # calls are captured too. Gated on ``IS_IOS`` rather than rubicon-objc
+    # being importable, so installing the ``[ios]`` extra on macOS does
+    # not silently swap ``sys.stdout`` on a dev machine.
+    if IS_IOS:
+        try:
+            from . import _ios_log
+
+            _ios_log.install()
+        except Exception:
+            pass
+
     _IOS_PAGE_REGISTRY: _Dict[int, Any] = {}
 
     def _ios_register_page(vc_instance: Any, host_obj: Any) -> None:

pythonnative/templates/ios_template/ios_template/ViewController.swift

@@ -27,13 +27,18 @@ class ViewController: UIViewController {
         super.viewDidLoad()
         // Ensure a visible background when created programmatically (storyboards set this automatically)
         view.backgroundColor = .systemBackground
-        NSLog("[PN][ViewController] viewDidLoad")
-        if let bundleId = Bundle.main.bundleIdentifier {
-            NSLog("[PN] Bundle Identifier: \(bundleId)")
-        }
-        NSLog("[PN] Bundle Path: \(Bundle.main.bundlePath)")
-        NSLog("[PN] Resource Path: \(Bundle.main.resourcePath ?? "nil")")
-        // Configure embedded Python if available in bundle
+
+        let firstInit = !ViewController.hasInitializedPython
+
+        // Signal to pythonnative that we're running on iOS. Read on the
+        // Python side (pythonnative.utils.IS_IOS) to gate iOS-only setup
+        // like sys.stdout redirection. Set before Python starts so it's
+        // visible to the very first import.
+        setenv("PN_PLATFORM", "ios", 1)
+
+        // Configure embedded Python if available in bundle. PYTHONHOME /
+        // PYTHONPATH only need to be set once per process, but setting them
+        // again is harmless and keeps the flow simple.
         if let resourcePath = Bundle.main.resourcePath {
             let pyStd = "\(resourcePath)/python-stdlib"
             let pyDyn = "\(resourcePath)/python-stdlib/lib-dynload"
@@ -44,8 +49,6 @@ class ViewController: UIViewController {
             }
             setenv("PYTHONHOME", pyStd, 1)
             setenv("PYTHONPATH", pyPath, 1)
-            NSLog("[PN] Set PYTHONHOME=\(pyStd)")
-            NSLog("[PN] Set PYTHONPATH=\(pyPath)")
         }
         #if canImport(PythonKit)
         // Ensure PythonKit knows where to load the Python library from when using an embedded framework.
@@ -53,34 +56,25 @@ class ViewController: UIViewController {
             let frameworkLib = "\(bundlePath)/Frameworks/Python.framework/Python"
             setenv("PYTHON_LIBRARY", frameworkLib, 1)
             if FileManager.default.fileExists(atPath: frameworkLib) {
-                if !ViewController.hasInitializedPython {
-                    NSLog("[PN] Using embedded Python lib at: \(frameworkLib)")
+                if firstInit {
                     PythonLibrary.useLibrary(at: frameworkLib)
                     ViewController.hasInitializedPython = true
-                } else {
-                    NSLog("[PN] Python library already initialized; skipping useLibrary")
                 }
                 pythonReady = true
             } else {
                 NSLog("[PN] Embedded Python library not found at: \(frameworkLib)")
             }
         }
-        NSLog("[PN] PythonKit available; attempting Python bootstrap")
         let sys = Python.import("sys")
-        NSLog("[PN] Python version: \(sys.version)")
-        NSLog("[PN] Initial sys.path: \(sys.path)")
+        if firstInit {
+            // One concise bootstrap line per process; per-page detail is left
+            // to Python-side print() statements streamed via pn run ios.
+            let shortVersion = "\(sys.version)".split(separator: "\n").first.map(String.init) ?? "\(sys.version)"
+            NSLog("[PN] Python \(shortVersion) initialized")
+        }
         if let resourcePath = Bundle.main.resourcePath {
             sys.path.append(resourcePath)
             sys.path.append("\(resourcePath)/app")
-            NSLog("[PN] Updated sys.path: \(sys.path)")
-            // List bundled resources to verify Python files are present
-            let fm = FileManager.default
-            let appDir = "\(resourcePath)/app"
-            if let entries = try? fm.contentsOfDirectory(atPath: appDir) {
-                NSLog("[PN] Contents of /app in bundle: \(entries)")
-            } else {
-                NSLog("[PN] Could not list contents of \(appDir).")
-            }
         }
         // Determine which Python page to load
         let pagePath: String = requestedPagePath ?? "app.main_page.MainPage"

pythonnative/utils.py

@@ -5,6 +5,7 @@ importing platform-specific packages at module level.
 """
 
 import os
+import sys
 from typing import Any, Optional
 
 # ======================================================================
@@ -12,6 +13,7 @@ from typing import Any, Optional
 # ======================================================================
 
 _is_android: Optional[bool] = None
+_is_ios: Optional[bool] = None
 
 
 def _detect_android() -> bool:
@@ -27,10 +29,40 @@ def _detect_android() -> bool:
     return False
 
 
+def _detect_ios() -> bool:
+    """Detect whether we're running inside an iOS app bundle.
+
+    Signals, in priority order:
+
+    - Explicit ``PN_PLATFORM=ios`` env var (set by the iOS template's
+      ``ViewController.swift`` before Python starts). This is the
+      canonical signal and survives even on hosts where ``sys.platform``
+      is generic ``darwin``.
+    - ``sys.platform == "ios"`` (CPython 3.13+ native iOS builds).
+    - ``/CoreSimulator/Devices/`` in ``$HOME`` (iOS Simulator fallback
+      if the template signal is missing for some reason).
+
+    Crucially, having ``rubicon-objc`` importable is *not* enough:
+    developers frequently install it on macOS via the ``[ios]`` extra,
+    and treating that as iOS would cause subtle side effects
+    (e.g. stdout redirection) on desktop machines.
+    """
+    if os.environ.get("PN_PLATFORM") == "ios":
+        return True
+    if sys.platform == "ios":
+        return True
+    home = os.environ.get("HOME", "")
+    if "/CoreSimulator/Devices/" in home:
+        return True
+    return False
+
+
 def _ensure_platform_detection() -> None:
-    global _is_android
+    global _is_android, _is_ios
     if _is_android is None:
         _is_android = _detect_android()
+    if _is_ios is None:
+        _is_ios = (not _is_android) and _detect_ios()
 
 
 def _get_is_android() -> bool:
@@ -39,7 +71,14 @@ def _get_is_android() -> bool:
     return _is_android
 
 
+def _get_is_ios() -> bool:
+    _ensure_platform_detection()
+    assert _is_ios is not None
+    return _is_ios
+
+
 IS_ANDROID: bool = _get_is_android()
+IS_IOS: bool = _get_is_ios()
 
 # ======================================================================
 # Android context management

{pythonnative-0.8.0.dist-info → pythonnative-0.9.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pythonnative
-Version: 0.8.0
+Version: 0.9.0
 Summary: Cross-platform native UI toolkit for Android and iOS
 Author: Owen Carey
 License: MIT License

{pythonnative-0.8.0.dist-info → pythonnative-0.9.0.dist-info}/RECORD

@@ -1,15 +1,16 @@
-pythonnative/__init__.py,sha256=PJ5VzzASR3xUdgP1iPlGtwXaxzNmC-c_UlJeKu0mCBQ,2038
+pythonnative/__init__.py,sha256=zKplWL38v3kFMeQ8Q2VqnjF-nAM5vx3EW8UIKqJddDo,2038
+pythonnative/_ios_log.py,sha256=dkTSUeOF9xRQjgxMYdH6EohjzjmeInwOfr-_0tkBmpE,2639
 pythonnative/components.py,sha256=zF24vXM6halq-fweLtLHxZrmBrUKCa9c44hf9Bych-Y,12767
 pythonnative/element.py,sha256=RBUsXzzzM7KdK-NqMD-InVPKdAb8XJ0h0VpI2rwsfHs,1795
 pythonnative/hooks.py,sha256=bqnJvEpbYSlbwkBKphT5lLEXQ1mO6AlO4r9SCTBlu7w,13768
 pythonnative/hot_reload.py,sha256=dtppJaQI6Rl7muCTMgLjFNsD4_F4yYnkEpliCLaaWm8,4508
 pythonnative/navigation.py,sha256=dDY9qBPLJKr2NnvdIDs8Xy-6kFesQNCEaLjUDT-0_l8,19042
-pythonnative/page.py,sha256=ya-UUk_0_lO2YLx3UmBjtPL0j1YXItzP3VhPIloRhXQ,16168
+pythonnative/page.py,sha256=J1mC6jVAu6IjFSwDGPU3cMfiXLPHoW2RbyZ1kj3OSfk,16814
 pythonnative/reconciler.py,sha256=EuB8InxqlbZpZ0qI8hSjwNQsS-lsvh0vdqGzTnmY1M8,14133
 pythonnative/style.py,sha256=NG58FSJCBTBBWRrDOyUiHZsTxQDA3jg2PSOcCsU2F5g,3882
-pythonnative/utils.py,sha256=IqR_GYknveM_NfAblcaizg9S66hCZfrfiH08HzpOc-4,2537
+pythonnative/utils.py,sha256=dp-cOYSflWvsY9Qh851OeBq-x6S8W1cx4nyjDxlsd0M,3859
 pythonnative/cli/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-pythonnative/cli/pn.py,sha256=Yi-RHjl3wUWHgGdwtA4UyEDy-tnjpmBB-PGupyDTae0,32823
+pythonnative/cli/pn.py,sha256=KGDbxRYtZHUS4rId_Br6oI7kEGl0pcRAo5UGztUvTN4,37478
 pythonnative/native_modules/__init__.py,sha256=M_4SW-wCZ8azLuB0JLwUc8PESw00xMCM887-HuN9YNo,647
 pythonnative/native_modules/camera.py,sha256=b3UErkABhBm2nQ-e72lEeFOgXoVDY6245cV6TN9iPBk,3509
 pythonnative/native_modules/file_system.py,sha256=2fvYsIboCtjEyxmVeV72glOjtc9fJN3jTM6uaccru6E,4478
@@ -59,7 +60,7 @@ pythonnative/templates/android_template/gradle/wrapper/gradle-wrapper.properties
 pythonnative/templates/ios_template/ios_template/AppDelegate.swift,sha256=_6G8GNcw4idXd75qKgQKTDCr45Ez73QB8WTvhBqqcMw,1349
 pythonnative/templates/ios_template/ios_template/Info.plist,sha256=ZQIJGpo8Y2qP0j29xqOsIEGvPpEVICLTAw2NehC5CSo,704
 pythonnative/templates/ios_template/ios_template/SceneDelegate.swift,sha256=lqtre92dc6d6s-f4ieh_M_4xmc_zMGW79j46tDu9cOY,2177
-pythonnative/templates/ios_template/ios_template/ViewController.swift,sha256=eRyxIIVYAYWY9Lt9IH498C2c0FDERUcq-L2TalkEoe0,8315
+pythonnative/templates/ios_template/ios_template/ViewController.swift,sha256=5bVNJ4TT6GIaICzVxl8hgcFmBgaPqjiCivlJzFy0p7c,7920
 pythonnative/templates/ios_template/ios_template/Assets.xcassets/Contents.json,sha256=D9Sbo8NYXHCWeOAEaoIcPGBoXscGNyDTDTo0SL46IIs,63
 pythonnative/templates/ios_template/ios_template/Assets.xcassets/AccentColor.colorset/Contents.json,sha256=mvZQhvowtJJS-uGhIlcxaR3nlPd3WvdNcb7-tQfRK3w,123
 pythonnative/templates/ios_template/ios_template/Assets.xcassets/AppIcon.appiconset/Contents.json,sha256=VUwGr7K_geOvQjFh5VKB6iVXV1mi0tjGMinUmB2JvQs,177
@@ -70,9 +71,9 @@ pythonnative/templates/ios_template/ios_template.xcodeproj/project.xcworkspace/x
 pythonnative/templates/ios_template/ios_templateTests/ios_templateTests.swift,sha256=YnwzZx7yXB13xKAXEGNgz17VuhWeqkHTRTtBJ2Vu3_E,1238
 pythonnative/templates/ios_template/ios_templateUITests/ios_templateUITests.swift,sha256=l2Pwa50F_rv-qPu2go6e4bQernM6PTQJeNPFl_c4ivY,1387
 pythonnative/templates/ios_template/ios_templateUITests/ios_templateUITestsLaunchTests.swift,sha256=f5JrG0uVtLMeJQy26Yyz7Om-JUkT220osqcbeIVkj2g,815
-pythonnative-0.8.0.dist-info/licenses/LICENSE,sha256=A69iG7TIAe6KkGQf6xoVHkc5JSZtOr5eRSvC5iuivnI,1067
-pythonnative-0.8.0.dist-info/METADATA,sha256=FZB-auwBCmhEBCt3nKpY7ZSNN3mF6_kbDLjVNWwfBMw,6692
-pythonnative-0.8.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
-pythonnative-0.8.0.dist-info/entry_points.txt,sha256=iUtDawWSAJAEyWTycpZxDuYz73ol31butpzDIEAgPO0,48
-pythonnative-0.8.0.dist-info/top_level.txt,sha256=kT4SEATY2ywzrZ2Pgea6_zxyym44Q_PbOsUoOYjJLFE,13
-pythonnative-0.8.0.dist-info/RECORD,,
+pythonnative-0.9.0.dist-info/licenses/LICENSE,sha256=A69iG7TIAe6KkGQf6xoVHkc5JSZtOr5eRSvC5iuivnI,1067
+pythonnative-0.9.0.dist-info/METADATA,sha256=YOu6Me-TqLtHWoWkL8A8UWp6WY9f-OzzkSfXZp8X86s,6692
+pythonnative-0.9.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+pythonnative-0.9.0.dist-info/entry_points.txt,sha256=iUtDawWSAJAEyWTycpZxDuYz73ol31butpzDIEAgPO0,48
+pythonnative-0.9.0.dist-info/top_level.txt,sha256=kT4SEATY2ywzrZ2Pgea6_zxyym44Q_PbOsUoOYjJLFE,13
+pythonnative-0.9.0.dist-info/RECORD,,