pythonhere 0.1.4__py3-none-any.whl → 0.2.0__py3-none-any.whl

pythonhere/__init__.py

@@ -1,8 +1,8 @@
 """PythonHere Jupyter magic."""
+
 from herethere.magic import load_ipython_extension
 
 from .magic_here import shortcuts  # noqa
 from .version_here import __version__  # noqa
 
-
 __all__ = ("load_ipython_extension",)

pythonhere/android_here.py

@@ -0,0 +1,100 @@
+"""Android specific functions."""
+
+# pylint: disable=invalid-name,import-error,import-outside-toplevel
+import uuid
+from pathlib import Path
+
+from android import activity as android_activity
+from jnius import autoclass, cast
+from kivy.logger import Logger
+
+Context = autoclass("android.content.Context")
+Icon = autoclass("android.graphics.drawable.Icon")
+Intent = autoclass("android.content.Intent")
+PythonActivity = autoclass("org.kivy.android.PythonActivity")
+ShortcutInfoBuilder = autoclass("android.content.pm.ShortcutInfo$Builder")
+System = autoclass("java.lang.System")
+Uri = autoclass("android.net.Uri")
+
+
+def get_current_intent() -> Intent:
+    """Return the intent that started Python activity."""
+    return PythonActivity.mActivity.getIntent()
+
+
+def get_startup_script(intent: None = None) -> str | None:
+    """Return script entrypoint that was passed to a given, or current, intent."""
+    if not intent:
+        intent = get_current_intent()
+    data = intent.getData()
+    return data and data.toString()
+
+
+def restart_app(script: str = None):
+    """Restart app, with a script as a starting point if provided."""
+    Logger.info("PythonHere: restart requested with a script: %s", script)
+    activity = PythonActivity.mActivity
+    intent = Intent(activity.getApplicationContext(), PythonActivity)
+    intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
+    intent.setFlags(Intent.FLAG_ACTIVITY_CLEAR_TASK)
+
+    if script:
+        intent.setData(Uri.parse(script))
+
+    activity.startActivity(intent)
+    System.exit(0)
+
+
+def bind_run_script_on_new_intent():
+    """Add handler for new intent event:
+    restart app with entrypoint of a new intent.
+    """
+
+    def on_new_intent(intent):
+        Logger.info("PythonHere: on_new_intent")
+        restart_app(get_startup_script(intent))
+        Logger.error("PythonHere: app was not restarted")
+
+    android_activity.bind(on_new_intent=on_new_intent)
+
+
+def create_shortcut_icon() -> Icon:
+    """Create icon to use for a shurtcut."""
+    activity = PythonActivity.mActivity
+    Drawable = autoclass(f"{activity.getPackageName()}.R$drawable")
+    context = cast("android.content.Context", activity.getApplicationContext())
+    return Icon.createWithResource(context, Drawable.icon)
+
+
+def resolve_script_path(script: str) -> str:
+    """Resolve path against upload directory."""
+    from kivy.app import App
+
+    if script.startswith("/"):
+        path = Path(script)
+    else:
+        app = App.get_running_app()
+        path = Path(app.upload_dir) / script
+    return str(path.resolve(strict=True))
+
+
+def pin_shortcut(script: str, label: str):
+    """Request a pinned shortcut creation to run a Python script."""
+    activity = PythonActivity.mActivity
+    context = cast("android.content.Context", activity.getApplicationContext())
+
+    intent = Intent(activity.getApplicationContext(), PythonActivity)
+    intent.setAction(Intent.ACTION_MAIN)
+    intent.setData(Uri.parse(resolve_script_path(script)))
+
+    shortcut = (
+        ShortcutInfoBuilder(context, f"pythonhere-{uuid.uuid4().hex}")
+        .setShortLabel(label)
+        .setLongLabel(label)
+        .setIntent(intent)
+        .setIcon(create_shortcut_icon())
+        .build()
+    )
+
+    manager = activity.getSystemService(Context.SHORTCUT_SERVICE)
+    manager.requestPinShortcut(shortcut, None)

pythonhere/enum_here.py

@@ -1,4 +1,5 @@
 """Enums."""
+
 from enum import Enum
 
 

pythonhere/exception_manager_here.kv

@@ -0,0 +1,22 @@
+<-UnhandledExceptionPopupHere>:
+    title: "Unhandled Exception catched"
+    BoxLayout:
+        orientation: 'vertical'
+        padding: 10
+        spacing: 20
+        Label:
+            size_hint_y: None
+            font_size: '18sp'
+            height: '24sp'
+            text: 'Exception details: '
+        ScrollView:
+            CodeInput:
+                id: catched_exception_code_input_here
+                text: root.message
+                size_hint: 1, None
+                height: self.minimum_height
+        Button:
+            size_hint_y: None
+            height: '40sp'
+            text: 'OK, continue'
+            on_press: root.dismiss()

pythonhere/exception_manager_here.py

@@ -1,46 +1,26 @@
 """App exceptions manager."""
+
 import asyncio
 import traceback
-from typing import Optional
+from pathlib import Path
 
 from kivy.base import (
     ExceptionHandler,
     ExceptionManager,
 )
 from kivy.clock import Clock
-from kivy.properties import StringProperty  # pylint: disable=no-name-in-module
 from kivy.lang import Builder
 from kivy.logger import Logger
+from kivy.properties import StringProperty  # pylint: disable=no-name-in-module
 from kivy.uix.popup import Popup
 
 
 def load_exception_popup_style():
     """Load KV rules for `UnhandledExceptionPopupHere`."""
-    Builder.load_string(
-        """<-UnhandledExceptionPopupHere>:
-    title: "Unhandled Exception catched"
-    BoxLayout:
-        orientation: 'vertical'
-        padding: 10
-        spacing: 20
-        Label:
-            size_hint_y: None
-            font_size: '18sp'
-            height: '24sp'
-            text: 'Exception details: '
-        ScrollView:
-            CodeInput:
-                id: catched_exception_code_input_here
-                text: root.message
-                size_hint: 1, None
-                height: self.minimum_height
-        Button:
-            size_hint_y: None
-            height: '40sp'
-            text: 'OK, continue'
-            on_press: root.dismiss()
-    """
-    )
+    kv_path = str(Path(__file__).with_suffix(".kv"))
+
+    if kv_path not in Builder.files:
+        Builder.load_file(kv_path)
 
 
 class ErrorMessageOnException(ExceptionHandler):
@@ -48,9 +28,9 @@ class ErrorMessageOnException(ExceptionHandler):
 
     def handle_exception(self, exception) -> int:
         """Handle a exception."""
-        Logger.exception("Unhandled Exception catched")
         if isinstance(exception, (asyncio.CancelledError, KeyboardInterrupt)):
             return ExceptionManager.RAISE
+        Logger.exception("Unhandled Exception catched")
         show_exception_popup()
         return ExceptionManager.PASS
 
@@ -63,10 +43,14 @@ class UnhandledExceptionPopupHere(Popup):
 
 def install_exception_handler():
     """Install `ErrorMessageOnException` exception handler."""
-    ExceptionManager.add_handler(ErrorMessageOnException())
+    if not any(
+        isinstance(handler, ErrorMessageOnException)
+        for handler in ExceptionManager.handlers
+    ):
+        ExceptionManager.add_handler(ErrorMessageOnException())
 
 
-def show_exception_popup(exc: Optional[Exception] = None):
+def show_exception_popup(exc: Exception | None = None):
     """Show exception popup."""
     load_exception_popup_style()
     if exc:

pythonhere/launcher_here.py

@@ -0,0 +1,46 @@
+"""Utilities for launching scripts."""
+
+import os
+import runpy
+import sys
+from pathlib import Path
+
+from kivy import platform
+from kivy.logger import Logger
+
+
+def run_script(script: str):
+    """Execute given script."""
+    Logger.info("PythonHere: Run script %s", script)
+    try:
+        path = Path(script).resolve(strict=True)
+    except FileNotFoundError:
+        Logger.error("Script not found: %s", script)
+        raise Exception(f"Script not found: {script}") from None
+
+    original_cwd = str(Path.cwd())
+    original_sys_path = sys.path[:]
+    try:
+        script_dir = path.parent
+        os.chdir(str(script_dir))
+        sys.path.insert(0, str(script_dir))
+        runpy.run_path(str(path), run_name="__main__")
+    finally:
+        os.chdir(original_cwd)
+        sys.path = original_sys_path
+
+
+def try_startup_script():
+    """Execute startup script, if it was passed to app."""
+    if platform != "android":
+        return
+    import android_here  # pylint: disable=import-outside-toplevel
+
+    try:
+        android_here.bind_run_script_on_new_intent()
+        script = android_here.get_startup_script()
+        if script:
+            run_script(script)
+    except Exception:
+        Logger.exception("PythonHere: Error while starting script")
+        raise

pythonhere/magic_here/shortcuts.py

@@ -4,11 +4,10 @@
 from base64 import b64decode
 from io import BytesIO, StringIO
 
-from PIL import Image as PILImage
-from IPython.display import display
 import click
-from herethere.there.commands import there_group, there_code_shortcut
-
+from herethere.there.commands import there_code_shortcut, there_group
+from IPython.display import display
+from PIL import Image as PILImage
 
 KV_COMMAND_TEMPLATE = r"""
 from window_here import load_kv_string
@@ -21,6 +20,11 @@ from window_here import encoded_screenshot
 sys.stderr.write(encoded_screenshot())
 """
 
+PIN_COMMAND_TEMPLATE = """
+from android_here import pin_shortcut
+pin_shortcut(script="{script}", label="{label}")
+"""
+
 
 @there_code_shortcut
 @click.option(
@@ -62,10 +66,22 @@ def screenshot(ctx, width, output):
     img = PILImage.open(BytesIO(data)).convert("RGB")
     if width:
         height = int(width * img.size[1] // img.size[0])
-        img = img.resize((width, height), PILImage.ANTIALIAS)
+        resampling = getattr(PILImage, "Resampling", PILImage)
+        resample_filter = getattr(resampling, "LANCZOS", PILImage.LANCZOS)
+        img = img.resize((width, height), resample_filter)
 
     if output:
         img.save(output)
         output.close()
 
     display(img)
+
+
+@there_code_shortcut
+@click.option("-l", "--label", type=str, default="", help="Label for shortcut")
+@click.argument("script", nargs=1)
+def pin(code: str, script: str, label: str) -> str:  # pylint: disable=unused-argument
+    """Create pinned shortcut to run a Python script from Android home screen."""
+    if not label:
+        label = script.split("/")[-1]
+    return PIN_COMMAND_TEMPLATE.format(script=script, label=label)

pythonhere/main.py

@@ -1,15 +1,29 @@
 """PythonHere app."""
+
+# pylint: disable=wrong-import-order,wrong-import-position
+
+from launcher_here import try_startup_script
+
+try:
+    try_startup_script()  # run script entrypoint, if it was passed
+except Exception as exc:
+    startup_script_exception = exc  # pylint: disable=invalid-name
+else:
+    startup_script_exception = None  # pylint: disable=invalid-name
+
 import asyncio
 import os
-from pathlib import Path
 import sys
-from typing import Any, Dict
+import threading
+from pathlib import Path
+from typing import Any
 
+from enum_here import ScreenName, ServerState
+from exception_manager_here import install_exception_handler, show_exception_popup
 from kivy.app import App
+from kivy.clock import Clock
+from kivy.config import Config, ConfigParser
 from kivy.logger import Logger
-
-from enum_here import ScreenName
-from exception_manager_here import install_exception_handler
 from patches_here import monkeypatch_kivy
 from server_here import run_ssh_server
 from window_here import reset_window_environment
@@ -22,13 +36,25 @@ class PythonHereApp(App):
 
     def __init__(self):
         super().__init__()
-        self.server_task = None
+        self.server_task: asyncio.Task | None = None
+        self.app_task: asyncio.Task | None = None
+        self.asyncio_loop: asyncio.AbstractEventLoop | None = None
         self.settings = None
+
+        # Created once a running asyncio loop exists.
+        self.ssh_server_config_ready: asyncio.Event | None = None
+        self.ssh_server_started: asyncio.Event | None = None
+        self.ssh_server_connected: asyncio.Event | None = None
+
+        self.ssh_server_namespace = {}
+        self.icon = "data/logo/logo-32.png"
+
+    def init_asyncio_state(self):
+        """Initialize asyncio-owned state after the event loop is running."""
+        self.asyncio_loop = asyncio.get_running_loop()
         self.ssh_server_config_ready = asyncio.Event()
         self.ssh_server_started = asyncio.Event()
         self.ssh_server_connected = asyncio.Event()
-        self.ssh_server_namespace = {}
-        self.icon = "data/logo/logo-32.png"
 
     @property
     def upload_dir(self) -> str:
@@ -38,59 +64,120 @@ class PythonHereApp(App):
         upload_dir.mkdir(exist_ok=True)
         return str(upload_dir)
 
+    @property
+    def config_path(self) -> str:
+        """Path to the application config file."""
+        root_dir = Path(self.user_data_dir or ".").resolve()
+        return str(root_dir / "config.ini")
+
+    def load_config(self) -> ConfigParser:
+        """Returning the application configuration."""
+        Config.read(self.config_path)  # Override the configuration file location
+        return super().load_config()
+
     def build(self):
         """Initialize application UI."""
         super().build()
         install_exception_handler()
-
         self.settings = self.root.ids.settings
-
         self.ssh_server_namespace.update(
             {
                 "app": self,
                 "root": self.root,
             }
         )
-
         self.update_server_config_status()
-        self.root.switch_screen(
-            ScreenName.here
-            if self.ssh_server_config_ready.is_set()
-            else ScreenName.settings
-        )
+        if startup_script_exception:
+            Clock.schedule_once(
+                lambda _: show_exception_popup(startup_script_exception), 0
+            )
 
-    def run_app(self):
-        """Run application and SSH server tasks."""
-        self.ssh_server_started = asyncio.Event()
-        self.server_task = asyncio.ensure_future(run_ssh_server(self))
-        return asyncio.gather(self.async_run_app(), self.server_task)
+    async def run_app(self):
+        """Run application and SSH server until either main task exits."""
+        self.init_asyncio_state()
+
+        self.server_task = asyncio.create_task(run_ssh_server(self))
+        self.app_task = asyncio.create_task(self.async_run_app())
+
+        tasks = (self.server_task, self.app_task)
+
+        try:
+            done, pending = await asyncio.wait(
+                tasks,
+                return_when=asyncio.FIRST_COMPLETED,
+            )
+
+            for task in pending:
+                task.cancel()
+
+            if pending:
+                await asyncio.gather(*pending, return_exceptions=True)
+
+            for task in done:
+                if task.cancelled():
+                    continue
+                exc = task.exception()
+                if exc is not None:
+                    raise exc
+        finally:
+            await self.cancel_app_tasks()
 
     async def async_run_app(self):
         """Run app asynchronously."""
         try:
-            await self.async_run(async_lib="asyncio")
+            await self.async_run()
             Logger.info("PythonHere: async run completed")
         except asyncio.CancelledError:
             Logger.info("PythonHere: app main task canceled")
+            raise
         except Exception as exc:
             Logger.exception(exc)
+            raise
+        finally:
+            if self.get_running_app():
+                self.stop()
+
+    async def cancel_app_tasks(self):
+        """Cancel tasks owned by this app."""
+        tasks = [
+            task
+            for task in (self.server_task, self.app_task)
+            if task is not None
+            and task is not asyncio.current_task()
+            and not task.done()
+        ]
+
+        for task in tasks:
+            task.cancel()
+
+        if tasks:
+            await asyncio.gather(*tasks, return_exceptions=True)
 
-        if self.server_task:
-            self.server_task.cancel()
+    def update_server_config_status(self):
+        """Check and update value of the `ssh_server_config_ready`, update screen."""
 
-        if self.get_running_app():
-            self.stop()
+        def update():
+            if all(self.get_pythonhere_config().values()):
+                if (
+                    self.asyncio_loop is not None
+                    and self.ssh_server_config_ready is not None
+                ):
+                    self.asyncio_loop.call_soon_threadsafe(
+                        self.ssh_server_config_ready.set
+                    )
 
-    def update_server_config_status(self):
-        """Check and update value of the `ssh_server_config_ready`."""
-        if all(self.get_pythonhere_config().values()):
-            self.ssh_server_config_ready.set()
+            Clock.schedule_once(lambda _: screen.update(), 0)
+
+        screen = self.root.ids.here_screen_manager
+        screen.current = ServerState.starting_server
+        self.root.switch_screen(ScreenName.here)
+        threading.Thread(name="update_server_config_status", target=update).start()
 
     def get_pythonhere_config(self):
         """Return user settings for SSH server."""
         return self.settings.get_pythonhere_config()
 
-    def update_ssh_server_namespace(self, namespace: Dict[str, Any]):
+    def update_ssh_server_namespace(self, namespace: dict[str, Any]):
         """Update SSH server namespace."""
         self.ssh_server_namespace.update(namespace)
 
@@ -109,8 +196,14 @@ class PythonHereApp(App):
     def on_ssh_connection_made(self):
         """New authenticated SSH client connected handler."""
         Logger.info("PythonHere: new SSH client connected")
+
+        if self.ssh_server_connected is None:
+            Logger.warning("PythonHere: SSH connected before asyncio state was ready")
+            return
+
         if not self.ssh_server_connected.is_set():
             self.ssh_server_connected.set()
+
             Logger.info("PythonHere: reset window environment")
             self.ssh_server_namespace["root"] = reset_window_environment()
             self.chdir(self.upload_dir)
@@ -122,7 +215,11 @@ class PythonHereApp(App):
         sys.path.insert(0, path)
 
 
+async def main():
+    """Run PythonHere."""
+    app = PythonHereApp()
+    await app.run_app()
+
+
 if __name__ == "__main__":
-    loop = asyncio.get_event_loop()
-    loop.run_until_complete(PythonHereApp().run_app())
-    loop.close()
+    asyncio.run(main())

pythonhere/network_here.py

@@ -1,5 +1,6 @@
 """Network addresses discovering."""
-from typing import Iterator, Tuple
+
+from collections.abc import Iterator
 
 from kivy import platform
 
@@ -14,7 +15,7 @@ else:
 
 def get_android_interface_addresses(
     interface: "NetworkInterface",
-) -> Iterator[Tuple[str, str]]:
+) -> Iterator[tuple[str, str]]:
     """Yields active IPv4 addresses for given network interface."""
     if interface.isUp():
         addresses = interface.getInetAddresses()
@@ -24,7 +25,7 @@ def get_android_interface_addresses(
                 yield interface.getDisplayName(), address.getHostAddress()
 
 
-def get_all_available_ipv4_adrresses() -> Iterator[Tuple[str, str]]:
+def get_all_available_ipv4_adrresses() -> Iterator[tuple[str, str]]:
     """Yields available interfaces with IPv4 addresses
     available for connections from there.
     """

pythonhere/patches_here.py

@@ -1,9 +1,8 @@
 """Monkey patching Kivy @('_')@."""
 
+import kivy.uix.widget
 from kivy.factory import Factory
 from kivy.lang.builder import BuilderBase
-import kivy.uix.widget
-
 
 _original_factory_register = Factory.register
 _original_builderbase_match = BuilderBase.match

pythonhere/pythonhere.kv

@@ -0,0 +1,49 @@
+#:kivy 1.0
+#:import RootLayout ui_here.layout_here.RootLayout
+#:import ScreenName enum_here.ScreenName
+#:import ServerState enum_here.ServerState
+#:import ServerScreenManager ui_here.server_screen_here.ServerScreenManager
+#:include ui_here/actionbar_here.kv
+#:include ui_here/common_here.kv
+#:include ui_here/connection_address_here.kv
+#:include ui_here/server_screen_here.kv
+#:include ui_here/settings_here.kv
+
+RootLayout:
+    orientation: "vertical"
+
+    ActionBar:
+        pos_hint: {"top": 1}
+
+        ActionView:
+            ActionPrevious:
+                title: ""
+                with_previous: False
+                app_icon: "data/logo/logo-32.png"
+
+            ScreenActionButton:
+                id: open_here_action
+                text: f"%{tc('H', 3)}ere"
+                screen: ScreenName.here
+            ScreenActionButton:
+                id: open_settings_action
+                text: f"{tc('S', 3)}ettings"
+                screen: ScreenName.settings
+
+            ActionButton:
+                text: f"{tc('Q', 3)}uit"
+                on_release: app.get_running_app().stop()
+
+    ScreenManager:
+        id: screen_manager
+        Screen:
+        Screen:
+            id: here_screen
+            name: ScreenName.here
+            ServerScreenManager:
+                id: here_screen_manager
+        Screen:
+            id: settings_screen
+            name: ScreenName.settings
+            SettingsHere:
+                id: settings