Render dictionaries in the positional argument of a tag as tag attributes

htmltools/core.py

@@ -70,6 +70,9 @@ class MetadataNode:
 
 TagT = TypeVar("TagT", bound="Tag")
 
+# Types that can be passed in as attributes to tag functions.
+TagAttrArg = Union[str, float, bool, None]
+
 # Types of objects that can be a child of a tag.
 TagChild = Union["Tagifiable", "Tag", MetadataNode, str]
 
@@ -79,13 +82,11 @@ class MetadataNode:
     "TagList",
     float,
     None,
+    Dict[str, TagAttrArg],  # i.e., tag attrbutes (e.g., {"id": "foo"})
     List["TagChildArg"],
     Tuple["TagChildArg", ...],
 ]
 
-# Types that can be passed in as attributes to tag functions.
-TagAttrArg = Union[str, int, float, bool, None]
-
 
 # Objects with tagify() methods are considered Tagifiable. Note that an object returns a
 # TagList, the children of the TagList must also be tagified.
@@ -245,9 +246,11 @@ def _repr_html_(self) -> str:
 # TagAttrs class
 # =============================================================================
 class TagAttrs(Dict[str, str]):
-    def __init__(self, **kwargs: TagAttrArg) -> None:
+    def __init__(
+        self, attrs: Mapping[str, TagAttrArg] = {}, **kwargs: TagAttrArg
+    ) -> None:
         super().__init__()
-        self.update(**kwargs)
+        self.update(attrs, **kwargs)
 
     def __setitem__(self, name: str, value: TagAttrArg) -> None:
         val = self._normalize_attr_value(value)
@@ -265,11 +268,32 @@ def update(  # type: ignore
 
     def _update(self, __m: Mapping[str, TagAttrArg]) -> None:
         attrs: Dict[str, str] = {}
-        for key, val in __m.items():
-            val_ = self._normalize_attr_value(val)
-            if val_ is None:
+
+        for k, v in __m.items():
+            val = self._normalize_attr_value(v)
+            if val is None:
                 continue
-            attrs[self._normalize_attr_name(key)] = val_
+            nm = self._normalize_attr_name(k)
+
+            sep = " "
+            if isinstance(val, HTML):
+                sep = HTML(sep)
+
+            final_val = val
+            attr_val = attrs.get(nm)
+            if attr_val:
+                final_val = attr_val + sep + final_val
+
+            attrs[nm] = final_val
+
+        for k, v in attrs.items():
+            self_v = self.get(k)
+            if self_v:
+                sep = " "
+                if isinstance(v, HTML):
+                    sep = HTML(sep)
+                attrs[k] = self_v + sep + v
+
         super().update(**attrs)
 
     @staticmethod
@@ -339,10 +363,23 @@ def __init__(
         **kwargs: TagAttrArg,
     ) -> None:
         self.name: str = _name
-        self.attrs: TagAttrs = TagAttrs(**kwargs)
+        self.attrs: TagAttrs = TagAttrs()
+
+        # As a workaround for Python not allowing for numerous keyword
+        # arguments of the same name, we treat any dictionaries in the
+        # positional arguments as attributes.
+        child_args: List[TagChildArg] = []
+        for arg in _flatten(args):
+            if isinstance(arg, dict):
+                self.attrs.update(arg)
+            else:
+                child_args.append(arg)
+
+        self.attrs.update(kwargs)
+
         self.children: TagList = TagList()
 
-        self.children.extend(args)
+        self.children.extend(child_args)
         if children:
             self.children.extend(children)
 

tests/test_tags.py

@@ -77,6 +77,17 @@ def test_tag_attrs_update():
     assert x.attrs == {"a": "1", "b": "2", "c": "C"}
 
 
+def test_tag_multiple_repeated_attrs():
+    x = div({"class": "foo", "class_": "bar"}, class_="baz")
+    y = div({"class": "foo"}, {"class_": "bar"}, class_="baz")
+    z = div({"class": "foo"}, {"class": "bar"}, class_="baz")
+    assert x.attrs == {"class": "foo bar baz"}
+    assert y.attrs == {"class": "foo bar baz"}
+    assert z.attrs == {"class": "foo bar baz"}
+    x.attrs.update({"class": "bap", "class_": "bas"}, class_="bat")
+    assert x.attrs == {"class": "foo bar baz bap bas bat"}
+
+
 def test_tag_shallow_copy():
     dep = HTMLDependency(
         "a", "1.1", source={"package": None, "subdir": "foo"}, script={"src": "a1.js"}
@@ -363,9 +374,8 @@ def test_attr_vals():
 
 
 def test_tag_normalize_attr():
-    # Note that x_ maps to x, and it gets replaced by the latter.
     x = div(class_="class_", x__="x__", x_="x_", x="x")
-    assert x.attrs == {"class": "class_", "x-": "x__", "x": "x"}
+    assert x.attrs == {"class": "class_", "x-": "x__", "x": "x_ x"}
 
     x = div(foo_bar="baz")
     assert x.attrs == {"foo-bar": "baz"}