@service now supports an optional service name argument to override the default pyscript.FUN_NAME.

@service can be used multiple times and also allows multiple arguments. Added error checking that
the same service isn't registered in two different global contexts.

Author: craigbarratt

custom_components/pyscript/eval.py

@@ -286,7 +286,7 @@ def __init__(self, func_def, code_list, code_str, global_ctx):
         self.exception_obj = None
         self.exception_long = None
         self.trigger = []
-        self.trigger_service = False
+        self.trigger_service = set()
         self.has_closure = False
 
     def get_name(self):
@@ -320,9 +320,9 @@ async def trigger_init(self):
             "mqtt_trigger": {"arg_cnt": {1, 2}, "rep_ok": True},
             "state_active": {"arg_cnt": {1}},
             "state_trigger": {"arg_cnt": {"*"}, "type": {list, set}, "rep_ok": True},
-            "service": {"arg_cnt": {0}},
+            "service": {"arg_cnt": {0, "*"}},
             "task_unique": {"arg_cnt": {1}},
-            "time_active": {"arg_cnt": {0, "*"}},
+            "time_active": {"arg_cnt": {"*"}},
             "time_trigger": {"arg_cnt": {0, "*"}, "rep_ok": True},
         }
         kwarg_check = {
@@ -388,8 +388,6 @@ async def trigger_init(self):
                 if dec_kwargs is None:
                     dec_kwargs = {}
             if dec_name == "service":
-                if self.name in (SERVICE_RELOAD, SERVICE_JUPYTER_KERNEL_START):
-                    raise SyntaxError(f"{exc_mesg}: @service conflicts with builtin service")
                 desc = self.doc_string
                 if desc is None or desc == "":
                     desc = f"pyscript function {self.name}()"
@@ -436,9 +434,17 @@ async def do_service_call(func, ast_ctx, data):
 
                     return pyscript_service_handler
 
-                Function.service_register(DOMAIN, self.name, pyscript_service_factory(self.name, self))
-                async_set_service_schema(Function.hass, DOMAIN, self.name, service_desc)
-                self.trigger_service = True
+                for srv_name in dec_args if dec_args else [f"{DOMAIN}.{self.name}"]:
+                    if type(srv_name) is not str or srv_name.count(".") != 1:
+                        raise ValueError(f"{exc_mesg}: @service argument must be a string with one period")
+                    domain, name = srv_name.split(".", 1)
+                    if name in (SERVICE_RELOAD, SERVICE_JUPYTER_KERNEL_START):
+                        raise SyntaxError(f"{exc_mesg}: @service conflicts with builtin service")
+                    Function.service_register(
+                        self.global_ctx_name, domain, name, pyscript_service_factory(self.name, self)
+                    )
+                    async_set_service_schema(Function.hass, domain, name, service_desc)
+                    self.trigger_service.add(srv_name)
                 continue
 
             if dec_name not in trig_decs:
@@ -457,7 +463,7 @@ async def do_service_call(func, ast_ctx, data):
             return
 
         if len(trig_decs) == 0:
-            if self.trigger_service:
+            if len(self.trigger_service) > 0:
                 self.global_ctx.trigger_register(self)
             return
 
@@ -501,9 +507,10 @@ def trigger_stop(self):
         for trigger in self.trigger:
             trigger.stop()
         self.trigger = []
-        if self.trigger_service:
-            self.trigger_service = False
-            Function.service_remove(DOMAIN, self.name)
+        for srv_name in self.trigger_service:
+            domain, name = srv_name.split(".", 1)
+            Function.service_remove(self.global_ctx_name, domain, name)
+        self.trigger_service = set()
 
     async def eval_decorators(self, ast_ctx):
         """Evaluate the function decorators arguments."""

custom_components/pyscript/function.py

@@ -70,6 +70,12 @@ class Function:
     #
     service_cnt = {}
 
+    #
+    # save the global_ctx name where a service is registered so we can raise
+    # an exception if it gets registered by a different global_ctx.
+    #
+    service2global_ctx = {}
+
     def __init__(self):
         """Warn on Function instantiation."""
         _LOGGER.error("Function class is not meant to be instantiated")
@@ -444,23 +450,30 @@ def create_task(cls, coro, ast_ctx=None):
         return cls.hass.loop.create_task(cls.run_coro(coro, ast_ctx=ast_ctx))
 
     @classmethod
-    def service_register(cls, domain, service, callback):
+    def service_register(cls, global_ctx_name, domain, service, callback):
         """Register a new service callback."""
         key = f"{domain}.{service}"
         if key not in cls.service_cnt:
             cls.service_cnt[key] = 0
+        if key not in cls.service2global_ctx:
+            cls.service2global_ctx[key] = global_ctx_name
+        if cls.service2global_ctx[key] != global_ctx_name:
+            raise ValueError(
+                f"{global_ctx_name}: can't register service {key}; already defined in {cls.service2global_ctx[key]}"
+            )
         cls.service_cnt[key] += 1
         cls.hass.services.async_register(domain, service, callback)
 
     @classmethod
-    def service_remove(cls, domain, service):
+    def service_remove(cls, global_ctx_name, domain, service):
         """Remove a service callback."""
         key = f"{domain}.{service}"
         if cls.service_cnt.get(key, 0) > 1:
             cls.service_cnt[key] -= 1
             return
         cls.service_cnt[key] = 0
         cls.hass.services.async_remove(domain, service)
+        cls.service2global_ctx.pop(key, None)
 
     @classmethod
     def task_done_callback_ctx(cls, task, ast_ctx):

docs/new_features.rst

@@ -34,6 +34,9 @@ The new features since 1.2.1 in master include:
 - Trigger decorators (``@state_trigger``, ``@time_trigger``, ``@event_trigger`` or ``@mqtt_trigger``) support
   an optional ``kwargs`` keyword argument that can be set to a ``dict`` of keywords and values, which are
   passed to the trigger function. See #157.
+- The ``@service`` decorator now takes one of more optional arguments to specify the name of the service of the
+  form ``"DOMAIN.SERVICE"``. The ``@service`` also can be used multiple times as an alternative to using multiple
+  arguments. The default continues to be ``pyscript.FUNC_NAME``.
 - Added ``@pyscript_executor`` decorator, which does same thing as ``@pyscript_compile`` and additionally wraps
   the resulting function with a call to ``task.executor``.  See #71.
 - Errors in trigger-related decorators (eg, wrong arguments, unregonized decorator type) raise exceptions rather

docs/reference.rst

@@ -908,15 +908,22 @@ Notice that `read_file` is called like a regular function, and it automatically
 ``task.executor``, which runs the compiled native python function in a new thread, and
 then returns the result.
 
-@service
-^^^^^^^^
+@service(service_name, ...)
+^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 The ``@service`` decorator causes the function to be registered as a service so it can be called
-externally. The ``@state_active`` and ``@time_active`` decorators don't affect the service - those
-only apply to time, state and event triggers specified by other decorators.
+externally. The string ``service_name`` argument is optional and defaults to ``"pyscript.FUNC_NAME"``,
+where ``FUNC_NAME`` is the name of the function. You can override that default by specifying
+a string with a single period of the form ``"DOMAIN.SERVICE"``. Multiple arguments and multiple
+``@service`` decorators can be used to register multiple names (eg, aliases) for the same function.
+
+Other trigger decorators like ``@state_active`` and ``@time_active`` don't affect the service.
+Those still allow state, time or other triggers to be specified in addition.
 
 The function is called with keyword parameters set to the service call parameters, plus
-``trigger_type`` is set to ``"service"``.
+``trigger_type`` is set to ``"service"``. The function definition should specify all the
+expected keyword arguments to match the service call parameters, or use the ``**kwargs``
+argument declaration to capture all the keyword arguments.
 
 The ``doc_string`` (the string immediately after the function declaration) is used as the service
 description that appears is in the Services tab of the Developer Tools page. The function argument

tests/test_apps_modules.py

@@ -58,7 +58,7 @@ def func11():
 from xyz2 import *
 
 @service
-def func2():
+def func20():
     pyscript.done = [get_x(), get_name(), other_name(), f_add(1, 5), f_mult(3, 6), f_add(10, 30), f_minus(50, 30)]
 """,
         #
@@ -198,7 +198,7 @@ async def state_changed(event):
     ret = await wait_until_done(notify_q)
     assert literal_eval(ret) == [1 + 2, 3 * 4, 10 + 20, 50 - 20]
 
-    await hass.services.async_call("pyscript", "func2", {})
+    await hass.services.async_call("pyscript", "func20", {})
     ret = await wait_until_done(notify_q)
     assert literal_eval(ret) == [99, "xyz2", "xyz2.other", 1 + 5, 3 * 6, 10 + 30, 50 - 30]
 

tests/test_decorator_errors.py

@@ -278,3 +278,117 @@ def func11():
         "TypeError: function 'func11' defined in file.hello: decorator @state_trigger argument 1 should be a string"
         in caplog.text
     )
+
+
+async def test_service_reload_error(hass, caplog):
+    """Test using a reserved name generates an error."""
+
+    await setup_script(
+        hass,
+        None,
+        dt(2020, 7, 1, 11, 59, 59, 999999),
+        """
+@service
+def reload():
+    pass
+""",
+    )
+    assert (
+        "SyntaxError: function 'reload' defined in file.hello: @service conflicts with builtin service"
+        in caplog.text
+    )
+
+
+async def test_service_state_active_extra_args(hass, caplog):
+    """Test using extra args to state_active generates an error."""
+
+    await setup_script(
+        hass,
+        None,
+        dt(2020, 7, 1, 11, 59, 59, 999999),
+        """
+@state_active("arg1", "too many args")
+def func4():
+    pass
+""",
+    )
+    assert (
+        "TypeError: function 'func4' defined in file.hello: decorator @state_active got 2 arguments, expected 1"
+        in caplog.text
+    )
+
+
+async def test_service_wrong_arg_type(hass, caplog):
+    """Test using too many args with service an error."""
+
+    await setup_script(
+        hass,
+        None,
+        dt(2020, 7, 1, 11, 59, 59, 999999),
+        """
+@service(1)
+def func5():
+    pass
+""",
+    )
+    assert (
+        "TypeError: function 'func5' defined in file.hello: decorator @service argument 1 should be a string"
+        in caplog.text
+    )
+
+
+async def test_time_trigger_wrong_arg_type(hass, caplog):
+    """Test using wrong argument type generates an error."""
+
+    await setup_script(
+        hass,
+        None,
+        dt(2020, 7, 1, 11, 59, 59, 999999),
+        """
+@time_trigger("wrong arg type", 50)
+def func6():
+    pass
+""",
+    )
+    assert (
+        "TypeError: function 'func6' defined in file.hello: decorator @time_trigger argument 2 should be a string"
+        in caplog.text
+    )
+
+
+async def test_decorator_kwargs(hass, caplog):
+    """Test invalid keyword arguments generates an error."""
+
+    await setup_script(
+        hass,
+        None,
+        dt(2020, 7, 1, 11, 59, 59, 999999),
+        """
+@time_trigger("invalid kwargs", arg=10)
+def func7():
+    pass
+""",
+    )
+    assert (
+        "TypeError: function 'func7' defined in file.hello: decorator @time_trigger valid keyword arguments are: kwargs"
+        in caplog.text
+    )
+
+
+async def test_decorator_kwargs2(hass, caplog):
+    """Test invalid keyword arguments generates an error."""
+
+    await setup_script(
+        hass,
+        None,
+        dt(2020, 7, 1, 11, 59, 59, 999999),
+        """
+@task_unique("invalid kwargs", arg=10)
+def func7():
+    pass
+""",
+    )
+    assert (
+        "TypeError: function 'func7' defined in file.hello: decorator @task_unique valid keyword arguments are: kill_me"
+        in caplog.text
+    )