added state.setattr() and direct attribute assignment; implements #49.

Author: craigbarratt

custom_components/pyscript/eval.py

@@ -1212,9 +1212,17 @@ async def recurse_assign(self, lhs, val):
                 return
             if not isinstance(var_name, str):
                 raise NotImplementedError(f"unknown lhs type {lhs} (got {var_name}) in assign")
-            if var_name.find(".") >= 0:
+            dot_count = var_name.count(".")
+            if dot_count == 1:
                 await State.set(var_name, val)
                 return
+            if dot_count == 2:
+                await State.setattr(var_name, val)
+                return
+            if dot_count > 0:
+                raise NameError(
+                    f"invalid name '{var_name}' (should be 'domain.entity' or 'domain.entity.attr'"
+                )
             if self.curr_func and var_name in self.curr_func.global_names:
                 self.global_sym_table[var_name] = val
                 return

custom_components/pyscript/state.py

@@ -126,12 +126,19 @@ def notify_var_get(cls, var_names, new_vars):
         return notify_vars
 
     @classmethod
-    async def set(cls, var_name, value, new_attributes=None, **kwargs):
+    async def set(cls, var_name, value=None, new_attributes=None, **kwargs):
         """Set a state variable and optional attributes in hass."""
         if var_name.count(".") != 1:
             raise NameError(f"invalid name {var_name} (should be 'domain.entity')")
-        if new_attributes is None:
+
+        state_value = None
+        if value is None or new_attributes is None:
             state_value = cls.hass.states.get(var_name)
+
+        if value is None and state_value:
+            value = state_value.state
+
+        if new_attributes is None:
             if state_value:
                 new_attributes = state_value.attributes
             else:
@@ -152,6 +159,15 @@ async def set(cls, var_name, value, new_attributes=None, **kwargs):
 
         cls.hass.states.async_set(var_name, value, new_attributes, context=context)
 
+    @classmethod
+    async def setattr(cls, var_attr_name, value):
+        """Set a state variable's attribute in hass."""
+        parts = var_attr_name.split(".")
+        if len(parts) != 3:
+            raise NameError(f"invalid name {var_attr_name} (should be 'domain.entity.attr')")
+
+        await cls.set(f"{parts[0]}.{parts[1]}", **{parts[2]: value})
+
     @classmethod
     async def register_persist(cls, var_name):
         """Register pyscript state variable to be persisted with RestoreState."""
@@ -253,7 +269,7 @@ async def service_call(*args, **kwargs):
         return value.attributes.get(parts[2])
 
     @classmethod
-    async def get_attr(cls, var_name):
+    async def getattr(cls, var_name):
         """Return a dict of attributes for a state variable."""
         if var_name.count(".") != 1:
             raise NameError(f"invalid name {var_name} (should be 'domain.entity')")
@@ -303,8 +319,10 @@ def register_functions(cls):
         functions = {
             "state.get": cls.get,
             "state.set": cls.set,
+            "state.setattr": cls.setattr,
             "state.names": cls.names,
-            "state.get_attr": cls.get_attr,
+            "state.getattr": cls.getattr,
+            "state.get_attr": cls.getattr,  # deprecated form; to be removed
             "state.persist": cls.persist,
             "pyscript.config": cls.pyscript_config,
         }

docs/reference.rst

@@ -117,10 +117,11 @@ you need their numeric value.
 State variables have attributes that can be accessed by adding the name of the attribute, as in
 ``DOMAIN.name.attr``. The attribute names and their meaning depend on the component that sets them,
 so you will need to look at the State tab in the Developer Tools to see the available attributes.
+You can set an attribute directly by assigning ``DOMAIN.name.attr = value``.
 
 In cases where you need to compute the name of the state variable dynamically, or you need to set or
-get the state attributes, you can use the built-in functions ``state.get()``, ``state.get_attr()``
-and ``state.set()``; see below.
+get all the state attributes, you can use the built-in functions ``state.get()``, ``state.getattr()``,
+``state.set()`` and ``state.setattr()``; see `State Functions <#state-variable-functions>`__.
 
 The function ``state.names(domain=None)`` returns a list of all state variable names (ie,
 ``entity_id``\ s) of a domain. If ``domain`` is not specified, it returns all HASS state
@@ -142,7 +143,7 @@ or call ``state.get("DOMAIN.entity.attr")``:
 - ``last_updated`` is the last UTC time the state entity was updated
 
 Note that these two values take precedence over any entity attributes that have the same name. If an
-entity has attributes with those names and you need to access them, use ``state.get_attr(name)``.
+entity has attributes with those names and you need to access them, use ``state.getattr(name)``.
 If you need to compute how many seconds ago the ``binary_sensor.test1`` state changed, you could
 do this:
 
@@ -624,9 +625,10 @@ which you can’t do if you are directly assigning to the variable:
   is thrown if the name doesn't exist. If ``name`` is a string of the form ``DOMAIN.entity.attr``
   then the attribute ``attr`` of the state variable ``DOMAIN.entity`` is returned; an
   ``AttributeError`` exception is thrown if that attribute doesn't exist.
-``state.get_attr(name)``
-  Returns a ``dict`` of attribute values for the state variable, or ``None``
-  if it doesn’t exist
+``state.getattr(name)``
+  Returns a ``dict`` of attribute values for the state variable, or ``None`` if it doesn’t exist.
+  In pyscript versions 0.32 and earlier, this function was ``state.get_attr()``. That deprecated
+  name is still supported, but will be removed in a future version.
 ``state.names(domain=None)``
   Returns a list of all state variable names (ie, ``entity_id``\ s) of a
   domain. If ``domain`` is not specified, it returns all HASS state variable (``entity_id``) names.
@@ -637,13 +639,17 @@ which you can’t do if you are directly assigning to the variable:
   are preserved across HASS restarts. This only applies to entities in the ``pyscript``
   domain (ie, name starts with ``pyscript.``). See `this section <#persistent-state>`__ for
   more information
-``state.set(name, value, new_attributes=None, **kwargs)``
+``state.set(name, value=None, new_attributes=None, **kwargs)``
   Sets the state variable to the given value, with the optional attributes. The optional 3rd
   argument, ``new_attributes``, should be a ``dict`` and it will overwrite all the existing
-  attributes if specified. If instead attributes are specified using keyword arguments, then other
-  attributes will not be affected. If no optional arguments are provided, just the state variable
-  value is set and the attributes are not changed. To clear the attributes, set
-  ``new_attributes={}``.
+  attributes if specified. If instead attributes are specified using keyword arguments, then
+  just those attributes will be set and other attributes will not be affected. If no optional
+  arguments are provided, just the state variable value is set and the attributes are not changed.
+  If no value is provided, just the state attributes are set and the value isn't changed.
+  To clear all the attributes, set ``new_attributes={}``.
+``state.setattr(name, value)``
+  Sets a state variable attribute to the given value. The ``name`` should fully specify the
+  state variable and attribute as a string in the form ``DOMAIN.entity.attr``.
 
 Note that in HASS, all state variable values are coerced into strings. For example, if a state
 variable has a numeric value, you might want to convert it to a numeric type (eg, using ``int()``

tests/test_unit_eval.py

@@ -139,17 +139,41 @@
     [
         """
 state.set("pyscript.var1", 100, attr1=1, attr2=3.5)
-chk1 = [pyscript.var1.attr1, pyscript.var1.attr2]
+chk = [[pyscript.var1.attr1, pyscript.var1.attr2]]
 pyscript.var1 += "xyz"
-chk2 = [pyscript.var1.attr1, pyscript.var1.attr2]
+chk.append([pyscript.var1.attr1, pyscript.var1.attr2])
 state.set("pyscript.var1", 200, attr3 = 'abc')
-chk3 = [pyscript.var1.attr1, pyscript.var1.attr2, pyscript.var1.attr3]
-chk4 = state.get_attr("pyscript.var1")
+chk.append([pyscript.var1.attr1, pyscript.var1.attr2, pyscript.var1.attr3])
+chk.append(state.getattr("pyscript.var1"))
 state.set("pyscript.var1", pyscript.var1, {})
-chk5 = state.get_attr("pyscript.var1")
-[chk1, chk2, chk3, chk4, chk5]
+chk.append(state.getattr("pyscript.var1"))
+state.set("pyscript.var1", pyscript.var1, new_attributes={"attr2": 8.5, "attr3": "xyz"})
+chk.append(state.getattr("pyscript.var1"))
+pyscript.var1.attr2 = "abc"
+chk.append(state.getattr("pyscript.var1"))
+state.set("pyscript.var1", attr1=123)
+state.set("pyscript.var1", attr3="def")
+chk.append(state.getattr("pyscript.var1"))
+pyscript.var1.attr4 = 987
+chk.append(state.getattr("pyscript.var1"))
+state.set("pyscript.var1", new_attributes={"attr2": 9.5, "attr3": "xyz"})
+chk.append(state.getattr("pyscript.var1"))
+chk.append(pyscript.var1)
+chk
 """,
-        [[1, 3.5], [1, 3.5], [1, 3.5, "abc"], {"attr1": 1, "attr2": 3.5, "attr3": "abc"}, {}],
+        [
+            [1, 3.5],
+            [1, 3.5],
+            [1, 3.5, "abc"],
+            {"attr1": 1, "attr2": 3.5, "attr3": "abc"},
+            {},
+            {"attr2": 8.5, "attr3": "xyz"},
+            {"attr2": "abc", "attr3": "xyz"},
+            {"attr1": 123, "attr2": "abc", "attr3": "def"},
+            {"attr1": 123, "attr2": "abc", "attr3": "def", "attr4": 987},
+            {"attr2": 9.5, "attr3": "xyz"},
+            "200",
+        ],
     ],
     ["eval('1+2')", 3],
     ["x = 5; eval('2 * x')", 10],