feat: Allow no layers, default to drawing combos only

Author: caksoylar

keymap_drawer/__main__.py

@@ -56,7 +56,7 @@ def draw(args: Namespace, config: Config) -> None:
     drawer = KeymapDrawer(
         config=config,
         out=args.output,
-        layers=yaml_data["layers"],
+        layers=yaml_data.get("layers", {}),
         layout=layout,
         combos=yaml_data.get("combos", []),
     )
@@ -72,7 +72,9 @@ def parse(args: Namespace, config: Config) -> None:
     """Call the appropriate parser for given args and dump YAML keymap representation to stdout."""
     if args.base_keymap:
         yaml_data = yaml.safe_load(args.base_keymap)
-        base = KeymapData(layers=yaml_data["layers"], combos=yaml_data.get("combos", []), layout=None, config=None)
+        base = KeymapData(
+            layers=yaml_data.get("layers", {}), combos=yaml_data.get("combos", []), layout=None, config=None
+        )
     else:
         base = None
 

keymap_drawer/draw/draw.py

@@ -191,30 +191,8 @@ def print_board(  # pylint: disable=too-many-locals
         ghost_keys: Sequence[int] | None = None,
     ) -> None:
         """Print SVG code representing the keymap."""
-        layers = deepcopy(self.keymap.layers)
-        if draw_layers:
-            assert all(l in layers for l in draw_layers), "Some layer names selected for drawing are not in the keymap"
-            layers = {name: layer for name, layer in layers.items() if name in draw_layers}
-
-        if keys_only:
-            combos_per_layer: dict[str, list[ComboSpec]] = {}
-        else:
-            combos_per_layer = self.keymap.get_combos_per_layer(layers)
-
-        if combos_only:
-            layers = {
-                name: [LayoutKey() for _ in range(len(self.layout))]
-                for name, combos in combos_per_layer.items()
-                if combos
-            }
-
-        if ghost_keys:
-            for key_position in ghost_keys:
-                assert (
-                    0 <= key_position < len(self.layout)
-                ), "Some key positions for `ghost_keys` are negative or too large for the layout"
-                for layer in layers.values():
-                    layer[key_position].type = "ghost"
+        # get final set of layers and combos per layer given the drawing options
+        layers, combos_per_layer = _resolve_layers_combos(self.keymap, draw_layers, keys_only, combos_only, ghost_keys)
 
         self.layer_names = set(layers)
 
@@ -257,3 +235,42 @@ def print_board(  # pylint: disable=too-many-locals
             self.print_footer(Point(board_w, board_h))
 
         self.output_stream.write("</svg>\n")
+
+
+def _resolve_layers_combos(
+    keymap: KeymapData,
+    draw_layers: Sequence[str] | None = None,
+    keys_only: bool = False,
+    combos_only: bool = False,
+    ghost_keys: Sequence[int] | None = None,
+) -> tuple[dict[str, list[LayoutKey]], dict[str, list[ComboSpec]]]:
+    layers = deepcopy(keymap.layers)
+    if draw_layers:
+        assert all(l in layers for l in draw_layers), "Some layer names selected for drawing are not in the keymap"
+        layers = {name: layer for name, layer in layers.items() if name in draw_layers}
+
+    if keys_only:
+        combos_per_layer: dict[str, list[ComboSpec]] = {}
+    elif not layers:
+        combos_per_layer = {"Combos": keymap.combos}
+    else:
+        combos_per_layer = keymap.get_combos_per_layer(layers)
+
+    assert keymap.layout is not None
+
+    if combos_only or not layers:
+        layers = {
+            name: [LayoutKey() for _ in range(len(keymap.layout))]
+            for name, combos in combos_per_layer.items()
+            if combos
+        }
+
+    if ghost_keys:
+        for key_position in ghost_keys:
+            assert (
+                0 <= key_position < len(keymap.layout)
+            ), "Some key positions for `ghost_keys` are negative or too large for the layout"
+            for layer in layers.values():
+                layer[key_position].type = "ghost"
+
+    return layers, combos_per_layer

keymap_drawer/keymap.py

@@ -148,7 +148,7 @@ def validate_trigger_keys(cls, val) -> list[str]:
 class KeymapData(BaseModel):
     """Represents all data pertaining to a keymap, including layers, combos and physical layout."""
 
-    layers: dict[str, list[LayoutKey]]
+    layers: dict[str, list[LayoutKey]] = {}
     combos: list[ComboSpec] = []
 
     # None-values only for use while parsing, i.e. no-layout mode
@@ -268,7 +268,6 @@ def combo_matcher(combo: ComboSpec, ref_layers: set[str]) -> int:
     @classmethod
     def parse_layers(cls, val) -> dict[str, list[LayoutKey]]:
         """Parse each key on layer from its key spec, flattening the spec if it contains sublists."""
-        assert val, "No layers found"
         return {
             layer_name: [
                 val if isinstance(val, LayoutKey) else LayoutKey.from_key_spec(val)
@@ -290,6 +289,12 @@ def create_layout(cls, vals):
         vals["layout"] = PhysicalLayoutGenerator(config=vals["config"], **vals["layout"]).generate()
         return vals
 
+    @model_validator(mode="after")
+    def check_valid(self):
+        """Check if there are any valid fields to use."""
+        assert self.layers or self.combos, "No layers or combos found, nothing to draw"
+        return self
+
     @model_validator(mode="after")
     def check_combos(self):
         """Resolve trigger keys if specified then validate combo positions are legitimate ones we can draw."""
@@ -309,7 +314,7 @@ def check_combos(self):
     def check_dimensions(self):
         """Validate that physical layout and layers have the same number of keys."""
         if self.layout is None:  # only check self-consistency for no-layout mode
-            if len(set(len(layer) for layer in self.layers.values())) != 1:
+            if len(set(len(layer) for layer in self.layers.values())) > 1:
                 counts = {layer_name: len(layer) for layer_name, layer in self.layers.items()}
                 raise AssertionError(f"Number of keys differ between layers. Key counts found: {counts}")
             return self