UI reload now the same as reload service

Author: craigbarratt

custom_components/pyscript/__init__.py

@@ -73,8 +73,45 @@ async def restore_state(hass):
             hass.states.async_set(entity_id, last_state.state, last_state.attributes)
 
 
+async def update_yaml_config(hass, config_entry):
+    """Update the yaml config."""
+    try:
+        conf = await async_hass_config_yaml(hass)
+    except HomeAssistantError as err:
+        _LOGGER.error(err)
+        return
+
+    config = PYSCRIPT_SCHEMA(conf.get(DOMAIN, {}))
+
+    #
+    # If data in config doesn't match config entry, trigger a config import
+    # so that the config entry can get updated
+    #
+    if config != config_entry.data:
+        await hass.config_entries.flow.async_init(DOMAIN, context={"source": SOURCE_IMPORT}, data=config)
+
+
+def start_global_contexts():
+    """Start all the file and apps global contexts."""
+    start_list = []
+    for global_ctx_name, global_ctx in GlobalContextMgr.items():
+        idx = global_ctx_name.find(".")
+        if idx < 0 or global_ctx_name[0:idx] not in {"file", "apps"}:
+            continue
+        global_ctx.set_auto_start(True)
+        start_list.append(global_ctx)
+    for global_ctx in start_list:
+        global_ctx.start()
+
+
 async def async_setup_entry(hass, config_entry):
     """Initialize the pyscript config entry."""
+    if Function.hass:
+        #
+        # reload yaml if this isn't the first time (ie, on reload)
+        #
+        await update_yaml_config(hass, config_entry)
+
     Function.init(hass)
     Event.init(hass)
     TrigTime.init(hass)
@@ -83,7 +120,6 @@ async def async_setup_entry(hass, config_entry):
     GlobalContextMgr.init()
 
     pyscript_folder = hass.config.path(FOLDER)
-
     if not await hass.async_add_executor_job(os.path.isdir, pyscript_folder):
         _LOGGER.debug("Folder %s not found in configuration folder, creating it", FOLDER)
         await hass.async_add_executor_job(os.makedirs, pyscript_folder)
@@ -100,36 +136,14 @@ async def reload_scripts_handler(call):
         """Handle reload service calls."""
         _LOGGER.debug("reload: yaml, reloading scripts, and restarting")
 
-        try:
-            conf = await async_hass_config_yaml(hass)
-        except HomeAssistantError as err:
-            _LOGGER.error(err)
-            return
-
-        config = PYSCRIPT_SCHEMA(conf.get(DOMAIN, {}))
-
-        # If data in config doesn't match config entry, trigger a config import
-        # so that the config entry can get updated
-        if config != config_entry.data:
-            await hass.config_entries.flow.async_init(DOMAIN, context={"source": SOURCE_IMPORT}, data=config)
-
+        await update_yaml_config(hass, config_entry)
         State.set_pyscript_config(config_entry.data)
 
         await unload_scripts()
 
         await load_scripts(hass, config_entry.data)
 
-        for global_ctx_name, global_ctx in GlobalContextMgr.items():
-            idx = global_ctx_name.find(".")
-            if idx < 0 or global_ctx_name[0:idx] not in {"file", "apps"}:
-                continue
-            global_ctx.set_auto_start(True)
-
-        for global_ctx_name, global_ctx in GlobalContextMgr.items():
-            idx = global_ctx_name.find(".")
-            if idx < 0 or global_ctx_name[0:idx] not in {"file", "apps"}:
-                continue
-            global_ctx.start()
+        start_global_contexts()
 
     hass.services.async_register(DOMAIN, SERVICE_RELOAD, reload_scripts_handler)
 
@@ -176,32 +190,22 @@ async def state_changed(event):
         }
         await State.update(new_vars, func_args)
 
-    async def start_triggers(event):
-        _LOGGER.debug("adding state changed listener and starting triggers")
+    async def hass_started(event):
+        _LOGGER.debug("adding state changed listener and starting global contexts")
         hass.data[DOMAIN][UNSUB_LISTENERS].append(hass.bus.async_listen(EVENT_STATE_CHANGED, state_changed))
-        for global_ctx_name, global_ctx in GlobalContextMgr.items():
-            idx = global_ctx_name.find(".")
-            if idx < 0 or global_ctx_name[0:idx] not in {"file", "apps"}:
-                continue
-            global_ctx.set_auto_start(True)
-        for global_ctx_name, global_ctx in GlobalContextMgr.items():
-            idx = global_ctx_name.find(".")
-            if idx < 0 or global_ctx_name[0:idx] not in {"file", "apps"}:
-                continue
-            global_ctx.start()
+        start_global_contexts()
 
-    async def stop_triggers(event):
-        _LOGGER.debug("stopping triggers")
-        for _, global_ctx in GlobalContextMgr.items():
-            global_ctx.stop()
+    async def hass_stop(event):
+        _LOGGER.debug("stopping global contexts")
+        await unload_scripts(unload_all=True)
         # tell reaper task to exit (after other tasks are cancelled)
         await Function.reaper_stop()
 
     # Store callbacks to event listeners so we can unsubscribe on unload
     hass.data[DOMAIN][UNSUB_LISTENERS].append(
-        hass.bus.async_listen(EVENT_HOMEASSISTANT_STARTED, start_triggers)
+        hass.bus.async_listen(EVENT_HOMEASSISTANT_STARTED, hass_started)
     )
-    hass.data[DOMAIN][UNSUB_LISTENERS].append(hass.bus.async_listen(EVENT_HOMEASSISTANT_STOP, stop_triggers))
+    hass.data[DOMAIN][UNSUB_LISTENERS].append(hass.bus.async_listen(EVENT_HOMEASSISTANT_STOP, hass_stop))
 
     return True
 
@@ -211,9 +215,6 @@ async def async_unload_entry(hass, config_entry):
     # Unload scripts
     await unload_scripts()
 
-    # tell reaper task to exit (after other tasks are cancelled)
-    await Function.reaper_stop()
-
     # Unsubscribe from listeners
     for unsub_listener in hass.data[DOMAIN][UNSUB_LISTENERS]:
         unsub_listener()
@@ -222,13 +223,14 @@ async def async_unload_entry(hass, config_entry):
     return True
 
 
-async def unload_scripts():
-    """Unload all scripts from GlobalContextMgr."""
+async def unload_scripts(unload_all=False):
+    """Unload all scripts from GlobalContextMgr with given name prefixes."""
     ctx_delete = {}
     for global_ctx_name, global_ctx in GlobalContextMgr.items():
-        idx = global_ctx_name.find(".")
-        if idx < 0 or global_ctx_name[0:idx] not in {"file", "apps", "modules"}:
-            continue
+        if not unload_all:
+            idx = global_ctx_name.find(".")
+            if idx < 0 or global_ctx_name[0:idx] not in {"file", "apps", "modules"}:
+                continue
         global_ctx.stop()
         ctx_delete[global_ctx_name] = global_ctx
     for global_ctx_name, global_ctx in ctx_delete.items():

custom_components/pyscript/function.py

@@ -41,6 +41,11 @@ class Function:
     #
     ast_functions = {}
 
+    #
+    # task id of the task that cancel and waits for other tasks
+    #
+    task_cancel_repeaer = None
+
     def __init__(self):
         """Warn on Function instantiation."""
         _LOGGER.error("Function class is not meant to be instantiated")
@@ -89,14 +94,18 @@ async def task_cancel_reaper(reaper_q):
                 except Exception:
                     _LOGGER.error("task_cancel_reaper: got exception %s", traceback.format_exc(-1))
 
-        cls.task_reaper_q = asyncio.Queue(0)
-        cls.task_cancel_repeaer = Function.create_task(task_cancel_reaper(cls.task_reaper_q))
+        if not cls.task_cancel_repeaer:
+            cls.task_reaper_q = asyncio.Queue(0)
+            cls.task_cancel_repeaer = Function.create_task(task_cancel_reaper(cls.task_reaper_q))
 
     @classmethod
     async def reaper_stop(cls):
         """Tell the reaper task to exit by sending a special task None."""
-        cls.task_cancel(None)
-        await cls.task_cancel_repeaer
+        if cls.task_cancel_repeaer:
+            cls.task_cancel(None)
+            await cls.task_cancel_repeaer
+            cls.task_cancel_repeaer = None
+            cls.task_reaper_q = None
 
     @classmethod
     async def async_sleep(cls, duration):

custom_components/pyscript/state.py

@@ -125,15 +125,15 @@ async def set(cls, var_name, value, new_attributes=None, **kwargs):
 
     @classmethod
     async def register_persist(cls, var_name):
-        """Persists a pyscript state variable using RestoreState."""
+        """Register pyscript state variable to be persisted with RestoreState."""
         if var_name.startswith("pyscript.") and var_name not in cls.persisted_vars:
             restore_data = await RestoreStateData.async_get_instance(cls.hass)
             restore_data.async_restore_entity_added(var_name)
             cls.persisted_vars.add(var_name)
 
     @classmethod
     async def persist(cls, var_name, default_value=None, default_attributes=None):
-        """Ensures a pyscript domain state variable is persisted."""
+        """Persist a pyscript domain state variable, and update with optional defaults."""
         if var_name.count(".") != 1 or not var_name.startswith("pyscript."):
             raise NameError(f"invalid name {var_name} (should be 'pyscript.entity')")
 

docs/reference.rst

@@ -6,8 +6,9 @@ Configuration
 
 Pyscript can be configured using the UI, or via yaml. To use the UI, go to the
 Configuration -> Integrations page and selection "+" to add ``Pyscript Python scripting``.
-After that, you can change the settings anytime by selecting Options under Pyscript
-in the Configuration page.
+After that, you can change the settings anytime by selecting "Options" under Pyscript
+in the Configuration page. You will need to select "reload" under Pyscript, or call
+the ``pyscript.reload`` service for the new settings to take effect.
 
 Alternatively, for yaml configuration, add ``pyscript:`` to ``<config>/configuration.yaml``.
 You can't mix these two methods - your initial choice determines how you should update
@@ -16,7 +17,8 @@ uninstall and reinstall pyscript.
 
 Pyscript has two optional configuration parameters that allow any python package to be
 imported and exposes the ``hass`` variable as a global (both options default to ``false``).
-In `<config>/configuration.yaml``:
+Assuming you didn't use the UI to configure pyscript, these can be set
+in `<config>/configuration.yaml``:
 
 .. code:: yaml
 
@@ -44,6 +46,10 @@ For example, applications ``my_app1`` and ``my_app2`` would be configured as:
         my_app2:
            # any settings for my_app2 go here
 
+Note that if you used the UI flow to configure pyscript, the ``allow_all_imports`` and
+`hass_is_global`` configuration settings will be ignored in the yaml file.  In that case
+you should omit them from the yaml, and just use yaml for pycript app configuration.
+
 As explained below, the use of ``apps`` with entries for each application by name below,
 is used to determine which application scripts are autoloaded. That's the only configuration
 structure that pyscript checks - any other parameters can be added and used as you like.
@@ -86,11 +92,12 @@ Even if you can’t directly call one function from another script file, HASS st
 global and services can be called from any script file.
 
 Reloading the ``.py`` files is accomplished by calling the ``pyscript.reload`` service, which is the
-one built-in service (so you can’t create your own service with that name). All function
-definitions, services and triggers are re-created on ``reload``, except for any active Jupyter
-sessions. Any currently running functions (ie, functions that have been triggered and are actively
-executing Python code or waiting inside ``task.sleep()`` or ``task.wait_until()``) are not stopped
-by ``reload`` - they continue to run until they finish (return). You can terminate these running
+one built-in service (so you can’t create your own service with that name). You can also reload by
+selecting Configuration -> Integrations -> Pyscript -> reload in the UI.  All function definitions,
+services and triggers are re-created on ``reload``, except for any active Jupyter sessions. Any
+currently running functions (ie, functions that have been triggered and are actively executing
+Python code or waiting inside ``task.sleep()`` or ``task.wait_until()``) are not stopped by
+``reload`` - they continue to run until they finish (return). You can terminate these running
 functions too on ``reload`` if you wish by calling ``task.unique()`` in the script file preamble
 (ie, outside any function definition), so it is executed on load and reload, which will terminate
 any running functions that have previously called ``task.unique()`` with the same argument.
@@ -99,6 +106,8 @@ any running functions that have previously called ``task.unique()`` with the sam
 State Variables
 ---------------
 
+These are typically called entities or ``entity_id`` in HASS.
+
 State variables can be accessed in any Python code simply by name. State variables (also called
 ``entity_id``) are of the form ``DOMAIN.name``, where ``DOMAIN`` is typically the name of the
 component that sets that variable. You can set a state variable by assigning to it.
@@ -567,12 +576,14 @@ variable has a numeric value, you might want to convert it to a numeric type (eg
 Persistent State
 ^^^^^^^^^^^^^^^^
 
-This method is provided to indicate that a particular entity_id should be persisted. This is only effective for entitys in the `pyscript` domain.
+This function specifies that a the state variable ``entity_id`` should be persisted (ie, its value
+and attributes are preserved across HASS restarts). This only applies to entities in the ``pyscript``
+domain (ie, name starts with ``pyscript.``).
 
 ``state.persist(entity_id, default_value=None, default_attributes=None)``
-  Indicates that the entity named in `entity_id` should be persisted. Optionally, a default value and default attributes can be provided.
-
-
+  Indicates that the entity ``entity_id`` should be persisted. Optionally, a default value and
+  default attributes (a ``dict``) can be specified, which are applied to the entity if it doesn't
+  exist or doesn't have any attributes respectively.
 
 Service Calls
 ^^^^^^^^^^^^^
@@ -1218,28 +1229,10 @@ is optional in pyscript):
 Persistent State
 ^^^^^^^^^^^^^^^^
 
-Pyscript has the ability to persist state in the `pyscript.` domain. This means that setting an entity like `pyscript.test` will cause it to be restored to its previous state when Home Assistant is restarted.
-
-This can be done in any of the usual ways to set the state of an `entity_id`:
-
-.. code:: python
-
-   set.state('pyscript.test', 'on')
-
-   pyscript.test = 'on'
-
-Attributes can be included:
-
-.. code:: python
-
-   set.state('pyscript.test', 'on', friendly_name="Test", device_class="motion")
-
-   pyscript.test = 'on'
-   pyscript.test.friendly_name = 'Test'
-   pyscript.test.device_class = 'motion'
-
-In order to ensure that the state of a particular entity persists, you need to request persistence explicitly. This must be done in a code location that will be certain to run at startup. Generally, this means outside of trigger functions.
-
+Pyscript has the ability to persist state variables in the ``pyscript.`` domain, meaning their
+values and attributes are preserved across HASS restarts.  To specify that the value of a particular
+entity persists, you need to request persistence explicitly. This must be done in a code location
+that will be certain to run at startup.
 
 .. code:: python
 
@@ -1250,10 +1243,5 @@ In order to ensure that the state of a particular entity persists, you need to r
      light.turn_on('light.overhead')
      pyscript.last_light_on = "light.overhead"
 
-With this in place, `state.persist()` will be called every time this script is parsed, ensuring this particular state will persist. 
-
-
-   
-
-  
-  
+With this in place, ``state.persist()`` will be called every time this script is parsed, ensuring the
+``pyscript.last_light_on`` state variable state will persist between HASS restarts.

tests/test_apps_modules.py

@@ -120,16 +120,16 @@ def glob_side_effect(path, recursive=None):
         print(f"glob_side_effect: path={path}, path_re={path_re}, result={result}")
         return result
 
+    conf = {"apps": {"world": {}}}
     with patch("custom_components.pyscript.os.path.isdir", return_value=True), patch(
         "custom_components.pyscript.glob.iglob"
     ) as mock_glob, patch("builtins.open", mock_open), patch(
-        "homeassistant.config.load_yaml_config_file", return_value={}
+        "homeassistant.config.load_yaml_config_file", return_value={"pyscript": conf}
     ), patch(
         "os.path.isfile"
     ) as mock_isfile:
         mock_isfile.side_effect = isfile_side_effect
         mock_glob.side_effect = glob_side_effect
-        conf = {"apps": {"world": {}}}
         assert await async_setup_component(hass, "pyscript", {DOMAIN: conf})
 
     notify_q = asyncio.Queue(0)

tests/test_config_flow.py

@@ -15,6 +15,7 @@
 @pytest.fixture(name="pyscript_bypass_setup")
 def pyscript_bypass_setup_fixture():
     """Mock component setup."""
+    logging.getLogger("pytest_homeassistant_custom_component.common").setLevel(logging.WARNING)
     with patch("custom_components.pyscript.async_setup_entry", return_value=True):
         yield
 
@@ -271,15 +272,16 @@ async def test_options_flow_user_no_change(hass, pyscript_bypass_setup):
 
 async def test_config_entry_reload(hass):
     """Test that config entry reload does not duplicate listeners."""
-    result = await hass.config_entries.flow.async_init(
-        DOMAIN,
-        context={"source": SOURCE_USER},
-        data=PYSCRIPT_SCHEMA({CONF_ALLOW_ALL_IMPORTS: True, CONF_HASS_IS_GLOBAL: True}),
-    )
-    await hass.async_block_till_done()
-    assert result["type"] == data_entry_flow.RESULT_TYPE_CREATE_ENTRY
-    entry = result["result"]
-    listeners = hass.bus.async_listeners()
-    await hass.config_entries.async_reload(entry.entry_id)
-    await hass.async_block_till_done()
-    assert listeners == hass.bus.async_listeners()
+    with patch("homeassistant.config.load_yaml_config_file", return_value={}):
+        result = await hass.config_entries.flow.async_init(
+            DOMAIN,
+            context={"source": SOURCE_USER},
+            data=PYSCRIPT_SCHEMA({CONF_ALLOW_ALL_IMPORTS: True, CONF_HASS_IS_GLOBAL: True}),
+        )
+        await hass.async_block_till_done()
+        assert result["type"] == data_entry_flow.RESULT_TYPE_CREATE_ENTRY
+        entry = result["result"]
+        listeners = hass.bus.async_listeners()
+        await hass.config_entries.async_reload(entry.entry_id)
+        await hass.async_block_till_done()
+        assert listeners == hass.bus.async_listeners()