Running native mode from a script.exe ignores settings

[J3ronimo]

Hi niceguys,

my native mode window ignores its settings when spawning it through an executable script.

Say we take the example from the website and installed it in a venv:

# main.py
from nicegui import app, ui

app.native.window_args['resizable'] = False
app.native.start_args['debug'] = True
app.native.settings['ALLOW_DOWNLOADS'] = True

ui.label('app running in native mode')
ui.button('enlarge', on_click=lambda: app.native.main_window.resize(1000, 700))

ui.run(native=True, window_size=(400, 300), fullscreen=False)

By "settings" I mean these values like "resizable".

Now I made this a "script" where script means the pip/distlib .exe that is created in .venv\Scripts when you pip install a project that has a [project.scripts] section in its pyproject.toml. Such script endpoints specify a callable from a module, which should be imported and called without args on launch of the script. Here this can be done by adding an empty dummy function at the bottom of the file, as long as the rest of the code runs on import, this is sufficient to spawn the native window.

Now though, the app.native settings don't get applied, i.e. no debug window shows, and the window is resizable.

Turns out for these settings to get applied, the multiprocessing.Process that runs the pywebview window has to import and run these lines of code again. This is the case when running as __main__, where mp runs the module again as __mp_main__ (some sort of special behavior there I guess), but not if it was imported like it is when running a script.exe. Here, only the parent process runs the module, but not the subprocess, i.e. no __mp_main__ will appear if you print __name__ at the start of the file. As a result, any settings done to app.native are basically irrelevant, since they're not seen by or transferred to the mp subprocess, which is the one that needs them as it spawns the window from its app context.

Another effect is that even if you run this as __main__, any modification to app.native that you do under a __main__ guard, say for example taking the value for the debug setting from a --debug flag from the command line, will not do anything. You will have to do the exact same argparsing again in an __mp_main__ guard of the subprocess to setup any window related flags in app.native there.

---

I finally found a workaround for this, which is

1. Launching through runpy:

# __init__.py
def run_main_from_script():
    runpy.run_module(f"{__name__}.main", run_name="__main__", alter_sys=True)

2. Sending all settings for app.native through env vars down to the subprocess, i.e.

• run cli / argparse if __main__
• somehow encode all relevant data into os.environ
• if __mp_main__, read settings from os.environ and apply to app.native.

This way, argparsing gets done only once, and all settings are applied correctly.

But that's quite tedious. Am I missing something here?

❓Would it make sense if NiceGUI somehow sent the app.native settings down to the mp.Process when creating it (as args or such), instead of relying on that it will read them itself by running the code again? Or would that conflict with something else?

Sorry for the long text, but I wanted to make it clear. ^^

[falkoschindler]

Hi @J3ronimo,

You seem to be running NiceGUI with reload=True (the default). This creates a parent process with a file watcher that spawns child processes with the actual app whenever a file changes. This doesn't make too much sense once you package your app for distribution. Therefore we recommend setting reload=False before packaging. This might resolve your problem.

[J3ronimo]

Hi Falko,

I already have reload=False - sorry I didn't mention that. Did it after reading this to rule out the reload mechanism as the cause. Native mode also uses multiprocessing so the effects may seem similar.

Here's a runnable, verifiable example of what I wanted to achieve:

# main.py
import os
import argparse
from nicegui import app, ui

print(f"I am {os.getpid()} running as {__name__}.")

app.native.window_args['resizable'] = False
app.native.start_args['debug'] = False      # initial default
app.native.settings['ALLOW_DOWNLOADS'] = True

ui.label('app running in native mode')
ui.button('enlarge', on_click=lambda: app.native.main_window.resize(1000, 700))

def cli():
    parser = argparse.ArgumentParser()
    parser.add_argument("--debug", "-d", action="store_true")
    args = parser.parse_args()
    app.native.start_args['debug'] = args.debug   # overwrite default from CLI

    ui.run(native=True, reload=False, window_size=(400, 300), fullscreen=False)


if __name__ == "__main__":
    cli()

Running this from a pip script linked to main:cli prints one line:

I am 13192 running as main.

Running this directly via python main.py prints two lines:

I am 24720 running as __main__.
I am 14380 running as __mp_main__.

The --debug CLI flag works in neither case, and resizable=False works only in the latter case since __mp_main__ for some reason runs the code again a second time, thereby executing the according line also in the subprocess. And only there it matters.

So currently there's no real way to be sure the pywebview subprocess ever runs the code with the UI settings. That's why I am asking if that couldn't / shouldn't be passed down somehow from the main process directly.