Merge branch 'master' into only-changes

Author: dlashua

custom_components/pyscript/function.py

@@ -190,13 +190,18 @@ def service_has_service(cls, domain, name):
     async def service_call(cls, domain, name, **kwargs):
         """Implement service.call()."""
         curr_task = asyncio.current_task()
-        if "context" in kwargs and isinstance(kwargs["context"], Context):
-            context = kwargs["context"]
-            del kwargs["context"]
-        else:
-            context = cls.task2context.get(curr_task, None)
-
-        await cls.hass.services.async_call(domain, name, kwargs, context=context)
+        hass_args = {}
+        for keyword, typ, default in [
+            ("context", [Context], cls.task2context.get(curr_task, None)),
+            ("blocking", [bool], None),
+            ("limit", [float, int], None),
+        ]:
+            if keyword in kwargs and type(kwargs[keyword]) in typ:
+                hass_args[keyword] = kwargs.pop(keyword)
+            elif default:
+                hass_args[keyword] = default
+
+        await cls.hass.services.async_call(domain, name, kwargs, **hass_args)
 
     @classmethod
     async def service_completions(cls, root):
@@ -255,15 +260,21 @@ def get(cls, name):
         def service_call_factory(domain, service):
             async def service_call(*args, **kwargs):
                 curr_task = asyncio.current_task()
-                if "context" in kwargs and isinstance(kwargs["context"], Context):
-                    context = kwargs["context"]
-                    del kwargs["context"]
-                else:
-                    context = cls.task2context.get(curr_task, None)
+                hass_args = {}
+                for keyword, typ, default in [
+                    ("context", [Context], cls.task2context.get(curr_task, None)),
+                    ("blocking", [bool], None),
+                    ("limit", [float, int], None),
+                ]:
+                    if keyword in kwargs and type(kwargs[keyword]) in typ:
+                        hass_args[keyword] = kwargs.pop(keyword)
+                    elif default:
+                        hass_args[keyword] = default
 
                 if len(args) != 0:
                     raise (TypeError, f"service {domain}.{service} takes no positional arguments")
-                await cls.hass.services.async_call(domain, service, kwargs, context=context)
+
+                await cls.hass.services.async_call(domain, service, kwargs, **hass_args)
 
             return service_call
 

custom_components/pyscript/global_ctx.py

@@ -266,8 +266,6 @@ def read_file(path):
                 _LOGGER.error("%s", exc)
                 return None
 
-        _LOGGER.debug("reading and parsing %s", filepath)
-
         source = await Function.hass.async_add_executor_job(read_file, filepath)
 
         if source is None:
@@ -288,4 +286,7 @@ def read_file(path):
             global_ctx.stop()
             return ast_ctx
         cls.set(global_ctx.get_name(), global_ctx)
+
+        _LOGGER.info("Loaded %s", filepath)
+
         return None

custom_components/pyscript/state.py

@@ -12,7 +12,7 @@
 
 _LOGGER = logging.getLogger(LOGGER_PATH + ".state")
 
-STATE_VIRTUAL_ATTRS = {"last_updated", "last_changed"}
+STATE_VIRTUAL_ATTRS = {"last_changed", "last_updated"}
 
 class StateVar(str):
     """Class for representing the value and attributes of a state variable."""
@@ -144,6 +144,15 @@ async def set(cls, var_name, value=None, new_attributes=None, **kwargs):
         if var_name.count(".") != 1:
             raise NameError(f"invalid name {var_name} (should be 'domain.entity')")
 
+        if isinstance(value, StateVar) and new_attributes is None:
+            #
+            # value is a StateVar, so extract the attributes and value
+            #
+            new_attributes = value.__dict__.copy()
+            for discard in STATE_VIRTUAL_ATTRS:
+                new_attributes.pop(discard, None)
+            value = str(value)
+
         state_value = None
         if value is None or new_attributes is None:
             state_value = cls.hass.states.get(var_name)
@@ -219,7 +228,7 @@ def exist(cls, var_name):
             len(parts) == 2
             or (parts[0] in cls.service2args and parts[2] in cls.service2args[parts[0]])
             or parts[2] in value.attributes
-            or parts[2] in {"last_changed", "last_updated"}
+            or parts[2] in STATE_VIRTUAL_ATTRS
         ):
             return True
         return False
@@ -248,11 +257,16 @@ async def get(cls, var_name):
             def service_call_factory(domain, service, entity_id, params):
                 async def service_call(*args, **kwargs):
                     curr_task = asyncio.current_task()
-                    if "context" in kwargs and isinstance(kwargs["context"], Context):
-                        context = kwargs["context"]
-                        del kwargs["context"]
-                    else:
-                        context = Function.task2context.get(curr_task, None)
+                    hass_args = {}
+                    for keyword, typ, default in [
+                        ("context", [Context], Function.task2context.get(curr_task, None)),
+                        ("blocking", [bool], None),
+                        ("limit", [float, int], None),
+                    ]:
+                        if keyword in kwargs and type(kwargs[keyword]) in typ:
+                            hass_args[keyword] = kwargs.pop(keyword)
+                        elif default:
+                            hass_args[keyword] = default
 
                     kwargs["entity_id"] = entity_id
                     if len(args) == 1 and len(params) == 1:
@@ -263,7 +277,7 @@ async def service_call(*args, **kwargs):
                         kwargs[param_name] = args[0]
                     elif len(args) != 0:
                         raise TypeError(f"service {domain}.{service} takes no positional arguments")
-                    await cls.hass.services.async_call(domain, service, kwargs, context=context)
+                    await cls.hass.services.async_call(domain, service, kwargs, **hass_args)
 
                 return service_call
 
@@ -303,7 +317,7 @@ def completions(cls, root):
             value = cls.hass.states.get(name)
             if value:
                 attr_root = root[last_period + 1 :]
-                attrs = set(value.attributes.keys()).union({"last_changed", "last_updated"})
+                attrs = set(value.attributes.keys()).union(STATE_VIRTUAL_ATTRS)
                 if parts[0] in cls.service2args:
                     attrs.update(set(cls.service2args[parts[0]].keys()))
                 for attr_name in attrs:

custom_components/pyscript/trigger.py

@@ -166,7 +166,6 @@ async def wait_until(
         event_trigger=None,
         timeout=None,
         state_hold=None,
-        **kwargs,
     ):
         """Wait for zero or more triggers, until an optional timeout."""
         if state_trigger is None and time_trigger is None and event_trigger is None:

docs/new_features.rst

@@ -1,7 +1,7 @@
 New Features
 ============
 
-The releases and releae notes are available on `GitHub <https://github.com/custom-components/pyscript/releases>`__.
+The releases and release notes are available on `GitHub <https://github.com/custom-components/pyscript/releases>`__.
 Use HACS to install different versions of pyscript.
 
 You can also install the master (head of tree) version from GitHub, either using HACS or manually.
@@ -54,9 +54,14 @@ The new features since 0.32 in master include:
   messages get displayed in VSCode. One benign but unresolved bug with VSCode is that when you connect
   to the pyscript kernel, VSCode starts a second pyscript Jupyter kernel, before shutting that second one
   down.
+- Service calls now accept ``blocking`` and ``limit`` parameters. The default behavior for a service call is
+  to run it in the background, but using ``blocking=True`` will force a task to wait up to ``limit`` seconds
+  for the service call to finish executing before continuing. Contributed by @raman325 (#85)
 
 The bug fixes since 0.32 in master include:
 
 - Jupyter autocomplete now works on multiline code blocks.
 - Improved error message reporting for syntax errors inside f-strings.
 - Fixed incorrect global context update on calling module that, in turn, does a callback (#58)
+- `task.wait_until` no longer silently ignores unrecognized keyword arguments (#80)
+- `task.wait_until` incorrectly ignored the keyword optional state_check_now argument (#81)

docs/reference.rst

@@ -48,7 +48,7 @@ For example, applications ``my_app1`` and ``my_app2`` would be configured as:
 
 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.
+you should omit them from the yaml, and just use yaml for pyscript 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
@@ -210,6 +210,11 @@ called by:
 
        service.call("myservice", "flash_light", light_name="front", light_color="red")
 
+When making a service call, either using the ``service.call`` function or the service name as the
+function, you can optionally pass the keyword argument ``blocking=True`` if you would like to wait
+for the service to finish execution before continuing execution in your function. You can also
+specify a timeout for a blocking service call using the ``limit=<number_of_seconds>`` parameters.
+
 Firing events
 -------------
 
@@ -535,7 +540,7 @@ When any trigger occurs (whether time, state or event), the ``@state_active`` ex
 evaluated. If it evaluates to ``False`` (or zero), the trigger is ignored and the trigger function
 is not called. This decorator is roughly equivalent to starting the trigger function with an
 ``if`` statement with the ``str_expr`` (the minor difference is that this decorator uses the
-``@state_trigger`` variable value, if present, when evalauting ``str_expr``, whereas an
+``@state_trigger`` variable value, if present, when evaluating ``str_expr``, whereas an
 ``if`` statement at the start of the function uses its current value, which might be different
 if the state variable was changed immediately after the trigger, and the ``.old`` value is
 not available).
@@ -691,8 +696,11 @@ or ``float()``). Attributes keep their native type.
 Service Calls
 ^^^^^^^^^^^^^
 
-``service.call(domain, name, **kwargs)``
-  calls the service ``domain.name`` with the given keyword arguments as parameters.
+``service.call(domain, name, blocking=False, limit=10, **kwargs)``
+  calls the service ``domain.name`` with the given keyword arguments as parameters. If ``blocking``
+  is ``True``, pyscript will wait for the service to finish executing before continuing the current
+  routine, or will wait a maximum of the number of seconds specified in the `limit` keyword
+  argument.
 ``service.has_service(domain, name)``
   returns whether the service ``domain.name`` exists.
 
@@ -992,7 +1000,7 @@ makes it convenient to just reload the script file or application you are develo
 affecting the others.
 
 A much better alternative to repeatedly modifying a script file and reloading it is to use Jupyter
-notebook to interactively deveop and test functions, triggers and services.
+notebook to interactively develop and test functions, triggers and services.
 
 Jupyter auto-completion (with `<TAB>`) is supported in Jupyter notebook, console and lab. It should
 work after you have typed at least the first character. After you hit `<TAB>` you should see a list
@@ -1275,7 +1283,7 @@ Access to Hass
 ^^^^^^^^^^^^^^
 
 If the ``hass_is_global`` configuration setting is set (default is off), then the variable ``hass``
-is available as a global variable in all pyscript contexts. That provides significant flexiblity
+is available as a global variable in all pyscript contexts. That provides significant flexibility
 in accessing HASS internals for cases where pyscript doesn't provide some binding or access.
 
 Ideally you should only use ``hass`` for read-only access. However, you do need a good understanding
@@ -1297,7 +1305,7 @@ You can use ``hass`` to compute sunrise and sunset times using the same method H
    print(f"today sunrise = {sunrise}, sunset = {sunset}")
 
 Here's another method that uses the installed version of ``astral`` directly, rather than the HASS
-helper function.  It's a bit more crytpic since it's a very old version of ``astral``, but you can
+helper function.  It's a bit more cryptic since it's a very old version of ``astral``, but you can
 see how the HASS configuration values are used:
 
 .. code:: python
@@ -1332,7 +1340,7 @@ be blocked, which will delay all other tasks.
 
 All the built-in functionality in pyscript is written using asynchronous code, which runs seamlessly
 together with all the other tasks in the main event loop. However, if you import Python packages and
-call functions that block (eg, file or networrk I/O) then you need to run those functions outside
+call functions that block (eg, file or network I/O) then you need to run those functions outside
 the main event loop. That can be accomplished wrapping those function calls with the
 ``task.executor`` function, which runs the function in a separate thread:
 
@@ -1440,5 +1448,5 @@ A handful of language features are not supported:
   functions that can be called and used in-line. There is a feature request to add this.
 
 Pyscript can call Python modules and packages, so you can always write your own native Python code
-(eg, if you need a generator or other unsupported feature) that can be called by psycript
+(eg, if you need a generator or other unsupported feature) that can be called by pyscript
 (see `Importing <#importing>`__ for how to create and import native Python modules in pyscript).

tests/test_function.py

@@ -12,6 +12,7 @@
 from pytest_homeassistant_custom_component.async_mock import MagicMock, Mock, mock_open, patch
 
 from homeassistant.const import EVENT_HOMEASSISTANT_STARTED, EVENT_STATE_CHANGED
+from homeassistant.core import Context
 from homeassistant.setup import async_setup_component
 
 
@@ -804,3 +805,95 @@ def set_add(entity_id=None, val1=None, val2=None):
     assert literal_eval(await wait_until_done(notify_q)) == [4, "pyscript.var1", "32"]
     assert literal_eval(await wait_until_done(notify_q)) == [5, "pyscript.var1", "50", "HomeAssistant"]
     assert "TypeError: service pyscript.set_add takes no positional arguments" in caplog.text
+
+
+async def test_service_call_params(hass):
+    """Test that hass params get set properly on service calls."""
+    with patch.object(hass.services, "async_call") as call, patch.object(
+        Function, "service_has_service", return_value=True
+    ):
+        Function.init(hass)
+        await Function.service_call(
+            "test", "test", context=Context(id="test"), blocking=True, limit=1, other_service_data="test"
+        )
+        assert call.called
+        assert call.call_args[0] == ("test", "test", {"other_service_data": "test"})
+        assert call.call_args[1] == {"context": Context(id="test"), "blocking": True, "limit": 1}
+        call.reset_mock()
+
+        await Function.service_call(
+            "test", "test", context=Context(id="test"), blocking=False, other_service_data="test"
+        )
+        assert call.called
+        assert call.call_args[0] == ("test", "test", {"other_service_data": "test"})
+        assert call.call_args[1] == {"context": Context(id="test"), "blocking": False}
+        call.reset_mock()
+
+        await Function.get("test.test")(
+            context=Context(id="test"), blocking=True, limit=1, other_service_data="test"
+        )
+        assert call.called
+        assert call.call_args[0] == ("test", "test", {"other_service_data": "test"})
+        assert call.call_args[1] == {"context": Context(id="test"), "blocking": True, "limit": 1}
+        call.reset_mock()
+
+        await Function.get("test.test")(
+            context=Context(id="test"), blocking=False, other_service_data="test"
+        )
+        assert call.called
+        assert call.call_args[0] == ("test", "test", {"other_service_data": "test"})
+        assert call.call_args[1] == {"context": Context(id="test"), "blocking": False}
+
+    # Stop all tasks to avoid conflicts with other tests
+    await Function.reaper_stop()
+
+
+async def test_serive_call_blocking(hass, caplog):
+    """Test that service calls with blocking=True actually block."""
+    notify_q = asyncio.Queue(0)
+
+    await setup_script(
+        hass,
+        notify_q,
+        [dt(2020, 7, 1, 12, 0, 0, 0)],
+        """
+seq_num = 0
+
+@time_trigger("startup")
+def func_startup():
+    global seq_num
+
+    seq_num += 1
+    pyscript.var1 = 1
+    pyscript.service1(blocking=True)
+    pyscript.done = [seq_num, pyscript.var1]
+
+    seq_num += 1
+    pyscript.service1(blocking=True)
+    pyscript.done = [seq_num, pyscript.var1]
+
+    seq_num += 1
+    service.call("pyscript", "service1", blocking=True)
+    pyscript.done = [seq_num, pyscript.var1]
+
+    seq_num += 1
+    pyscript.var1 = int(pyscript.var1) + 1
+    service.call("pyscript", "long_sleep", blocking=True, limit=1e-6)
+    pyscript.done = [seq_num, pyscript.var1]
+
+@service
+def long_sleep():
+    task.delay(10000)
+
+@service
+def service1():
+    pyscript.var1 = int(pyscript.var1) + 1
+
+""",
+        config={DOMAIN: {CONF_ALLOW_ALL_IMPORTS: True, CONF_HASS_IS_GLOBAL: True}},
+    )
+    hass.bus.async_fire(EVENT_HOMEASSISTANT_STARTED)
+    assert literal_eval(await wait_until_done(notify_q)) == [1, "2"]
+    assert literal_eval(await wait_until_done(notify_q)) == [2, "3"]
+    assert literal_eval(await wait_until_done(notify_q)) == [3, "4"]
+    assert literal_eval(await wait_until_done(notify_q)) == [4, "5"]