setting a state variable doesn't change attributes;

added state.get_attr() to get attributes;
state.set() can set or overwrite attributes, or leave them unchanged

Author: craigbarratt

README.md

@@ -261,9 +261,12 @@ State variables have attributes that can be accessed by adding the name of the a
 them, so you will need to look at the State tab in the Developer Tools to see the available
 attributes.
 
-In cases where you need to compute the name of the state variable dynamically, or you need to
-set the state attributes, you can use the built-in functions `state.get(name)` and
-`state.set(name, value, attr=None)`; see below.
+Starting in version 0.21, when you set a state variable, the existing attributes are not
+affected (they were previously removed).
+
+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.
 
 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 variable (entity) names.
@@ -582,14 +585,23 @@ set the attributes, which you can't do if you are directly assigning to the vari
 
 `state.get(name)` returns the value of the state variable, or `None` if it 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.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.
 
-`state.set(name, value, attr=None)` sets the state variable to the given value, with the optional attributes.
+`state.set(name, value, 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={}`.
 
 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()` or `float()`).
+Attributes keep their native type.
 
 #### Service Calls
 
@@ -605,11 +617,12 @@ parameters as the event data.
 
 #### Logging functions
 
-Four logging functions are provided, with increasing levels of severity:
+Five logging functions are provided, with increasing levels of severity:
 - `log.debug(str)`
 - `log.info(str)`
 - `log.warning(str)`
 - `log.error(str)`
+- `print(str)` is the same as `log.debug(str)`; currently `print` doesn't support other arguments.
 
 The [Logger](/integrations/logger/) component can be used to specify the logging level. Log messages
 below the configured level will not appear in the log. Each log message function uses a log name of

custom_components/pyscript/state.py

@@ -83,14 +83,16 @@ def notify_var_get(var_names):
 
     def set(var_name, value, attributes=None, **kwargs):
         """Set a state variable and optional attributes in hass."""
-        if len(var_name.split(".")) != 2:
-            _LOGGER.error(
-                "invalid variable name %s (should be 'domain.entity')", var_name
-            )
-            return
-        if attributes or kwargs:
-            if attributes is None:
+        if var_name.count(".") != 1:
+            raise NameError(f"invalid name {var_name} (should be 'domain.entity')")
+        if attributes is None:
+            state_value = State.hass.states.get(var_name)
+            if state_value:
+                attributes = state_value.attributes
+            else:
                 attributes = {}
+        if kwargs:
+            attributes = attributes.copy()
             attributes.update(kwargs)
         _LOGGER.debug("setting %s = %s, attr = %s", var_name, value, attributes)
         State.hass.states.async_set(var_name, value, attributes)
@@ -107,14 +109,23 @@ def get(var_name):
         """Get a state variable value or attribute from hass."""
         parts = var_name.split(".")
         if len(parts) != 2 and len(parts) != 3:
-            return None
+            raise NameError(f"invalid name {var_name} (should be 'domain.entity')")
         value = State.hass.states.get(f"{parts[0]}.{parts[1]}")
         if not value:
             return None
         if len(parts) == 2:
             return value.state
         return value.attributes.get(parts[2])
 
+    def get_attr(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')")
+        value = State.hass.states.get(var_name)
+        if not value:
+            return None
+        return value.attributes.copy()
+
     def completions(root):
         """Return possible completions of state variables."""
         words = set()
@@ -140,15 +151,16 @@ def completions(root):
                     words.add(name.entity_id)
         return words
 
-    async def entity_ids(domain=None):
-        """Implement entity_ids."""
+    async def names(domain=None):
+        """Implement names, which returns all entity_ids."""
         return State.hass.states.async_entity_ids(domain)
 
     def register_functions():
         """Register state functions."""
         functions = {
             "state.get": State.get,
             "state.set": State.set,
-            "state.names": State.entity_ids,
+            "state.names": State.names,
+            "state.get_attr": State.get_attr,
         }
         Handler.register(functions)

tests/custom_components/pyscript/test_unit_eval.py

@@ -176,6 +176,27 @@
         "pyscript.var1 = 1; pyscript.var2 = 2; set(state.names('pyscript'))",
         {"pyscript.var1", "pyscript.var2"},
     ],
+    [
+        """
+state.set("pyscript.var1", 100, attr1=1, attr2=3.5)
+chk1 = [pyscript.var1.attr1, pyscript.var1.attr2]
+pyscript.var1 += "xyz"
+chk2 = [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")
+state.set("pyscript.var1", pyscript.var1, {})
+chk5 = state.get_attr("pyscript.var1")
+[chk1, chk2, chk3, chk4, chk5]
+""",
+        [
+            [1, 3.5],
+            [1, 3.5],
+            [1, 3.5, "abc"],
+            {"attr1": 1, "attr2": 3.5, "attr3": "abc"},
+            {},
+        ],
+    ],
     ["eval('1+2')", 3],
     ["x = 5; eval('2 * x')", 10],
     ["x = 5; exec('x = 2 * x'); x", 10],