menuet 1.0.0__py3-none-any.whl

menuet/__init__.py

@@ -0,0 +1,25 @@
+from __future__ import annotations
+
+from menuet.action import Action
+from menuet.menu import Menu
+from menuet.model import (
+    ItemAction,
+    ItemGroup,
+    ItemMenu,
+    Model,
+    deserialize,
+    load,
+    loads,
+)
+
+__all__ = (
+    "Action",
+    "ItemAction",
+    "ItemGroup",
+    "ItemMenu",
+    "Menu",
+    "Model",
+    "deserialize",
+    "load",
+    "loads",
+)

menuet/action.py

@@ -0,0 +1,93 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+from attrs import define, field, validators
+from typing_extensions import Self
+
+from menuet.utils import (
+    passthrough,
+    to_cb_converter,
+    to_icon_converter,
+    to_tuple_converter,
+)
+
+if TYPE_CHECKING:
+    from collections.abc import Callable
+    from importlib.abc import Traversable
+
+
+ID_PATTERN = r"[a-z](?:[a-z-]*[a-z])?"
+
+
+@define(frozen=True, kw_only=True)
+class Action:
+    """Runtime action definition."""
+
+    id: str = field(validator=validators.matches_re(ID_PATTERN))
+    """Action identifier.
+
+    Identifier must abide by these rules:
+
+    - Must be **unique** in its [`Model`][menuet.Model]
+    - The **first** and **last** characters must be ascii lowercase `[a-z]`
+    - Other characters must be ascii lowercase or dash `[a-z-]`
+    """
+
+    cb: Callable[[], Any] = field(
+        converter=to_cb_converter,
+        eq=False,
+        default=passthrough,
+    )
+    """Callback to execute when action is requested."""
+
+    enabled: bool = field(default=True)  # TODO(tga): unused
+    """Whether the action is enabled."""
+
+    visible: bool = field(default=True)  # TODO(tga): unused
+    """Whether the action is visible in the menu."""
+
+    menu: tuple[str, ...] = field(default=(), converter=to_tuple_converter)
+    """Menu labels hierarchy.
+
+    The root menu is represented by an empty tuple `()`.
+    """
+
+    label: str | None = field(default=None)
+    """Display name."""
+
+    group: str | None = field(default=None)
+    """A group under `menu`.
+
+    Items under the same `menu` can be grouped together.
+    Groups are represented by separators.
+    """
+
+    icon: Traversable | None = field(default=None, converter=to_icon_converter)
+    """Path to an icon.
+
+    Icons are displayed alongside the `label`, if supported by the menu builder.
+    """
+
+    desc: str | None = field(default=None)
+    """Short description.
+
+    Displayed as a menu tooltip.
+    """
+
+    # TODO(tga): extra: Mapping[str, object]
+
+    @classmethod
+    def deserialize(cls, config: dict[str, Any]) -> Self:
+        """Deserialize `config` into a new instance."""
+        return cls(
+            id=config["id"],
+            cb=config.get("cb", passthrough),
+            enabled=config.get("enabled", True),
+            visible=config.get("visible", True),
+            menu=config.get("menu", ()),
+            label=config.get("label"),
+            group=config.get("group"),
+            icon=config.get("icon"),
+            desc=config.get("desc"),
+        )

menuet/builders/qt.py

@@ -0,0 +1,113 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from PySide6 import QtCore, QtGui, QtWidgets
+from PySide6.QtGui import QAction
+
+from menuet.model import ItemAction, ItemGroup, ItemMenu
+from menuet.utils import logger
+
+if TYPE_CHECKING:
+    from importlib.abc import Traversable
+
+    from menuet.model import MenuSortKey, Model
+
+__all__ = ("QMenuBuilder",)
+
+
+class QMenuBuilder:
+    """Qt Menu Builder."""
+
+    def __init__(
+        self,
+        model: Model,
+        *,
+        root_menu: QtWidgets.QMenu | str,
+        sort_key: MenuSortKey | None = None,
+    ) -> None:
+        self._model: Model = model
+        self._sort_key = sort_key
+        self._root_menu = root_menu
+
+    def build(self) -> QtWidgets.QMenu:
+        """Build menu."""
+        menus: dict[tuple[str, ...], QtWidgets.QMenu] = {}
+
+        if isinstance(self._root_menu, QtWidgets.QMenu):
+            root = self._root_menu
+            root.clear()
+        else:
+            root = QtWidgets.QMenu(self._root_menu)
+        menus[()] = root
+
+        for item in self._model.iter(sort_key=self._sort_key, recursive=True):
+            parent = menus[item.menu]
+
+            if isinstance(item, ItemGroup):
+                parent.addSection(item.inner or "")
+
+            elif isinstance(item, ItemMenu):
+                menu = QtWidgets.QMenu(item.inner.label)
+                menu.setIcon(qicon_from_file(item.inner.icon))
+                menu.setToolTipsVisible(True)
+                menu.setTearOffEnabled(False)
+                menu.setParent(parent, menu.windowFlags())
+                parent.addMenu(menu)
+                menus[item.path] = menu
+
+            elif isinstance(item, ItemAction):
+                action = QAction()
+                action.setText(item.inner.label or item.inner.id)
+                action.setIconVisibleInMenu(True)
+                action.setIcon(qicon_from_file(item.inner.icon))
+                action.setToolTip(item.inner.desc or "")
+                action.triggered.connect(item.inner.cb)
+                action.setParent(parent)
+                parent.addAction(action)
+
+            else:  # pragma: no cover
+                raise TypeError(item)
+
+        for menu in menus.values():
+            _fix_first_separator(menu)
+
+        return root
+
+
+def qicon_from_file(file: Traversable | None, size: int = 16) -> QtGui.QIcon:
+    """Initialize `QIcon` from `file` bytes.
+
+    If `file` is `None`, or contains an invalid pixmap,
+    an empty `QIcon` is returned.
+    """
+    if file is None:
+        return QtGui.QIcon()
+
+    if not file.is_file():
+        logger.debug("icon file does not exist or is not a file: '%s'", file)
+        return QtGui.QIcon()
+
+    pixmap = QtGui.QPixmap()
+    if not pixmap.loadFromData(file.read_bytes()):
+        logger.debug("failed to load icon file: '%s'", file)
+        return QtGui.QIcon()
+
+    pixmap = pixmap.scaled(QtCore.QSize(size, size))
+    return QtGui.QIcon(pixmap)
+
+
+def _fix_first_separator(menu: QtWidgets.QMenu) -> None:
+    """Fix cases where the first menu separator is not displayed.
+
+    If the first `menu` item is a separator,
+    prepend menu with a fake zero-sized action,
+    making the separator the second `menu` item, and visible.
+    """
+    first = menu.actions()[0] if menu.actions() else None
+    if first and first.isSeparator() and first.text() and first.isVisible():
+        widget = QtWidgets.QWidget(menu)
+        widget.setFixedSize(0, 0)
+        action = QtWidgets.QWidgetAction(menu)
+        action.setDefaultWidget(widget)
+        menu.insertAction(first, action)

menuet/builders/text.py

@@ -0,0 +1,128 @@
+from __future__ import annotations
+
+import enum
+from itertools import accumulate
+from typing import TYPE_CHECKING
+
+from attrs import frozen
+
+from menuet.model import ItemAction, ItemGroup, ItemMenu
+
+if TYPE_CHECKING:
+    from menuet.model import MenuSortKey, Model
+
+
+__all__ = ("Render", "TextMenuBuilder")
+
+
+@frozen
+class _Render:
+    child: str
+    last_child: str
+    menu: str
+    empty: str
+    group_suffix: str
+
+
+class Render(enum.Enum):
+    """[`TextMenuBuilder`][menuet.builders.text.TextMenuBuilder] render options."""
+
+    UTF8 = _Render(
+        child="├── ",
+        last_child="└── ",
+        menu="│   ",
+        empty="    ",
+        group_suffix=" ───",
+    )
+    ASCII = _Render(
+        child="|-- ",
+        last_child="`-- ",
+        menu="|   ",
+        empty="    ",
+        group_suffix=" ---",
+    )
+
+
+def _get_item_label(item: ItemMenu | ItemAction | ItemGroup) -> str:
+    if isinstance(item, ItemMenu):
+        return item.inner.label
+    if isinstance(item, ItemAction):
+        return item.inner.label or item.inner.id
+    if isinstance(item, ItemGroup):
+        return item.inner or ""
+    raise TypeError(type(item))  # pragma: no cover
+
+
+class TextMenuBuilder:
+    """Text menu builder."""
+
+    def __init__(
+        self,
+        model: Model,
+        *,
+        root_menu: str | None = None,
+        sort_key: MenuSortKey | None = None,
+        render: Render = Render.ASCII,
+    ) -> None:
+        self._model: Model = model
+        self._render: _Render = render.value
+        self._sort_key: MenuSortKey | None = sort_key
+        self._root_menu: str | None = root_menu
+
+    def build(self) -> str:
+        """Build menu."""
+        items = list(self._model.iter(sort_key=self._sort_key, recursive=True))
+        root = (self._root_menu,) if self._root_menu is not None else ()
+
+        # mapping of `{menu_path: item_path}` of last element for each `menu_path`
+        lasts: dict[tuple[str, ...], tuple[str, ...]] = {}
+        for item in items:
+            path = (*root, *item.path)
+            lasts[path[:-1]] = path
+
+        lasts_ = set(lasts.values())
+        lines: list[str] = []
+
+        if self._root_menu is not None:
+            line = self._get_ascii_line(label=self._root_menu, path=(), lasts=lasts_)
+            lines.append(line)
+
+        for item in items:
+            line = self._get_ascii_line(
+                label=_get_item_label(item),
+                path=(*root, *item.path),
+                lasts=lasts_,
+            )
+            if isinstance(item, ItemGroup):
+                line = f"{line}{self._render.group_suffix}"
+            lines.append(line)
+
+        return "\n".join(lines)
+
+    def _get_ascii_line(
+        self,
+        label: str,
+        *,
+        path: tuple[str, ...] = (),
+        lasts: set[tuple[str, ...]],
+    ) -> str:
+        chunks: list[str] = []
+
+        parents = path[:-1]
+        if parents:
+            # ("a", "b", "c") -> ("a", "b") ("a", "b", "c")
+            it: accumulate[tuple[str, ...]] = accumulate(
+                parents,
+                lambda t, s: (*t, s),
+                initial=(),
+            )
+            next(it)  # skip initial
+            next(it)  # skip root
+            for menu in it:
+                chunk = self._render.empty if menu in lasts else self._render.menu
+                chunks.append(chunk)
+            chunk = self._render.last_child if path in lasts else self._render.child
+            chunks.append(chunk)
+
+        chunks.append(label)
+        return "".join(chunks)

menuet/menu.py

@@ -0,0 +1,59 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+from attrs import define, field
+from typing_extensions import Self
+
+from menuet.utils import to_icon_converter, to_tuple_converter
+
+if TYPE_CHECKING:
+    from importlib.abc import Traversable
+
+
+@define(frozen=True, kw_only=True)
+class Menu:
+    """Menu node definition."""
+
+    label: str = field()
+    """Display name."""
+
+    menu: tuple[str, ...] = field(default=(), converter=to_tuple_converter)
+    """Menu labels hierarchy.
+
+    The root menu is represented by an empty tuple `()`.
+    """
+
+    group: str | None = field(default=None)
+    """A group under `menu`.
+
+    Items under the same `menu` can be grouped together.
+    Groups are represented by menu separators.
+    """
+
+    icon: Traversable | None = field(default=None, converter=to_icon_converter)
+    """Path to an icon.
+
+    Icons are displayed alongside the `label`, if supported by the menu builder.
+    """
+
+    desc: str | None = field(default=None)
+    """Short description.
+
+    Displayed as a menu tooltip.
+    """
+
+    @classmethod
+    def deserialize(cls, config: dict[str, Any]) -> Self:
+        """Deserialize `config` into a new instance."""
+        return cls(
+            label=config["label"],
+            menu=config.get("menu", ()),
+            group=config.get("group"),
+            icon=config.get("icon"),
+            desc=config.get("desc"),
+        )
+
+    def is_configured(self) -> bool:
+        """Whether this menu has any configuration beside `menu` and `label`."""
+        return self.icon is not None or self.group is not None or self.desc is not None

menuet/model.py

@@ -0,0 +1,280 @@
+from __future__ import annotations
+
+import sys
+from functools import reduce
+from itertools import chain
+from operator import getitem
+from typing import TYPE_CHECKING, Any, NamedTuple
+
+import attr
+from attrs import define, field
+
+from menuet.action import Action
+from menuet.menu import Menu
+
+if sys.version_info < (3, 11):
+    import tomli as tomllib  # ty: ignore[unresolved-import]
+else:
+    import tomllib
+
+if TYPE_CHECKING:
+    from collections.abc import Callable, Iterable, Iterator
+
+    from _typeshed import SupportsRead, SupportsRichComparison
+
+    MenuSortKey = Callable[[Menu | Action], SupportsRichComparison]
+
+__all__ = (
+    "ItemAction",
+    "ItemGroup",
+    "ItemMenu",
+    "Model",
+    "deserialize",
+    "load",
+    "loads",
+)
+
+
+@define
+class _MenuNode:
+    inner: Menu
+    parent: _MenuNode | None
+    menus: dict[str, _MenuNode] = field(factory=dict, init=False)
+    actions: dict[str, _ActionNode] = field(factory=dict, init=False)
+
+
+@define
+class _ActionNode:
+    inner: Action = field(on_setattr=attr.setters.frozen)
+    parent: _MenuNode
+
+
+def load(
+    fp: SupportsRead[bytes],
+    model: Model,
+    root_keys: tuple[str, ...] | None = None,
+) -> None:
+    """Load `fp` and deserialize its content to [`model`][menuet.Model].
+
+    Args:
+        fp: a `.read()`-supporting file-like object containing a TOML document.
+        model: Target model.
+        root_keys: The sequence of keys that lead to the root configuration structure.
+            For example, a `[tool.myapp.mymenu]` table (`("tool", "myapp", "mymenu")`)
+            in `pyproject.toml`.
+    """
+    config = tomllib.load(fp)
+    deserialize(config, model, root_keys)
+
+
+def loads(s: str, model: Model, root_keys: tuple[str, ...] | None = None) -> None:
+    """Load `s` and deserialize its content to [`model`][menuet.Model].
+
+    Args:
+        s: a `str` containing a TOML document.
+        model: Target model.
+        root_keys: The sequence of keys that lead to the root configuration structure.
+            For example, a `[tool.myapp.mymenu]` table (`("tool", "myapp", "mymenu")`)
+            in `pyproject.toml`.
+    """
+    config = tomllib.loads(s)
+    deserialize(config, model, root_keys)
+
+
+def deserialize(
+    config: dict[str, Any],
+    model: Model,
+    root_keys: tuple[str, ...] | None = None,
+) -> None:
+    """Deserialize `config` and add its content to the model.
+
+    Args:
+        config: A dict containing a configuration of menus and actions.
+        model: Target model.
+        root_keys: The sequence of keys that lead to the root configuration structure.
+            For example, a `[tool.myapp.mymenu]` table (`("tool", "myapp", "mymenu")`)
+            in `pyproject.toml`.
+    """
+    root_keys = root_keys if root_keys is not None else ()
+    # TODO(tga): try/except KeyError
+    config = reduce(getitem, root_keys, config)
+    for c in config.get("menu", []):
+        model.add_menu(Menu.deserialize(c))
+    for c in config.get("action", []):
+        model.add_action(Action.deserialize(c))
+
+
+class ItemGroup(NamedTuple):
+    """Group wrapper, returned by [`Model.iter`][menuet.Model.iter]."""
+
+    inner: str | None
+    menu: tuple[str, ...]
+
+    @property
+    def path(self) -> tuple[str, ...]:  # noqa: D102
+        return (*self.menu, self.inner or "")
+
+
+class ItemMenu(NamedTuple):
+    """Menu wrapper, returned by [`Model.iter`][menuet.Model.iter]."""
+
+    inner: Menu
+
+    @property
+    def menu(self) -> tuple[str, ...]:  # noqa: D102
+        return self.inner.menu
+
+    @property
+    def path(self) -> tuple[str, ...]:  # noqa: D102
+        return (*self.inner.menu, self.inner.label)
+
+
+class ItemAction(NamedTuple):
+    """Action wrapper, returned by [`Model.iter`][menuet.Model.iter]."""
+
+    inner: Action
+
+    @property
+    def menu(self) -> tuple[str, ...]:  # noqa: D102
+        return self.inner.menu
+
+    @property
+    def path(self) -> tuple[str, ...]:  # noqa: D102
+        return (*self.inner.menu, self.inner.id)
+
+
+def _default_sort_key(node: Menu | Action) -> SupportsRichComparison:
+    """Sort key for `Menu` items.
+
+    Sort, in order:
+
+    1. Sort groups alphabetically
+    2. Menus before actions in the current group
+    3. Finally, sort alphabetically
+    """
+    label = (node.label or node.id) if isinstance(node, Action) else node.label
+    return (
+        (node.group or "").lower(),
+        not isinstance(node, Menu),
+        label.lower(),
+    )
+
+
+class Model:
+    """The main `Action` and `Menu` storage abstraction."""
+
+    def __init__(self) -> None:
+        self._actions: dict[str, Action] = {}
+        self._menus: dict[tuple[str, ...], _MenuNode] = {}
+        self._menus[()] = _MenuNode(Menu(label="", menu=()), parent=None)
+
+    def add_action(self, action: Action) -> None:
+        """Add `action` to model."""
+        self._add_action(action)
+
+    def add_menu(self, menu: Menu) -> None:
+        """Add `menu` to model."""
+        self._add_menu(menu)
+
+    def get_action(self, id: str) -> Action:  # noqa: A002
+        """Return `Action` with given `id` in model.
+
+        Raises:
+            KeyError: `id` not found.
+        """
+        return self._actions[id]
+
+    def iter(
+        self,
+        menu: tuple[str, ...] = (),
+        *,
+        sort_key: MenuSortKey | None = None,
+        recursive: bool = False,
+    ) -> Iterator[ItemGroup | ItemMenu | ItemAction]:
+        """Iter menu items.
+
+        Args:
+            menu: The start menu. An empty tuple `()` (the default), starts at the top.
+            sort_key: Customize the sort order of menu items.
+            recursive: Iter sub-menus in depth-first search.
+        """
+        sort_key = sort_key or _default_sort_key
+        parent = self._menus[menu]
+        for item in self._iter_menu(parent, sort_key):
+            yield item
+            if isinstance(item, ItemMenu) and recursive:
+                yield from self.iter(
+                    menu=(*item.inner.menu, item.inner.label),
+                    sort_key=sort_key,
+                    recursive=True,
+                )
+
+    def _iter_menu(
+        self,
+        menu: _MenuNode,
+        sort_key: MenuSortKey,
+    ) -> Iterator[ItemGroup | ItemMenu | ItemAction]:
+        previous_group = None
+
+        nodes: Iterable[Menu | Action] = chain(
+            (node.inner for node in menu.menus.values()),
+            (node.inner for node in menu.actions.values()),
+        )
+        nodes = sorted(nodes, key=sort_key)
+
+        for node in nodes:
+            group = node.group
+            if group is not None and group != previous_group:
+                yield ItemGroup(group, menu=node.menu)
+                previous_group = group
+
+            yield ItemMenu(node) if isinstance(node, Menu) else ItemAction(node)
+
+    def _add_action(self, action: Action) -> _ActionNode:
+        if action.id in self._actions:
+            msg = f"Action {action.id!r} already exists in model"
+            raise ValueError(msg)
+
+        # add to tree
+        if action.menu:
+            parent = self._menus.get(action.menu)
+            if not parent:
+                parent = self._add_menu(
+                    Menu(label=action.menu[-1], menu=action.menu[:-1]),
+                )
+        else:
+            parent = self._menus[()]
+        node = _ActionNode(action, parent=parent)
+        parent.actions[action.id] = node
+
+        # add to map
+        self._actions[action.id] = action
+
+        return node
+
+    def _add_menu(self, menu: Menu) -> _MenuNode:
+        path = (*menu.menu, menu.label)
+        if path in self._menus:
+            msg = f"Menu {path!r} already exists in model"
+            raise ValueError(msg)
+
+        # add parent to tree
+        parent = self._menus.get(menu.menu)
+        if parent is None:
+            if menu.menu:
+                parent = self._add_menu(Menu(label=menu.menu[-1], menu=menu.menu[:-1]))
+            else:
+                parent = self._menus[()]
+
+        # add leaf to tree
+        node = parent.menus.get(menu.label)
+        if node is None:
+            node = _MenuNode(menu, parent=parent)
+            parent.menus[menu.label] = node
+        elif menu.is_configured() and not node.inner.is_configured():
+            node.inner = menu
+
+        # add to map
+        self._menus[path] = node
+
+        return node

menuet/utils.py

@@ -0,0 +1,119 @@
+from __future__ import annotations
+
+import importlib.resources
+import logging
+import webbrowser
+from collections.abc import Iterable
+from functools import partial
+from pathlib import Path
+from typing import TYPE_CHECKING, Any, Final, TypeVar
+
+if TYPE_CHECKING:
+    from collections.abc import Callable
+    from importlib.abc import Traversable
+
+_T = TypeVar("_T")
+
+logger: Final[logging.Logger] = logging.getLogger("menuet")
+
+
+def load_entry_point(value: str, /) -> Any:  # noqa: ANN401
+    """Create, load, and execute `value` entry point."""
+    from importlib.metadata import EntryPoint  # noqa: PLC0415
+
+    func = EntryPoint(name="", group="", value=value).load()
+    func()
+
+
+def load_resource(value: str, /) -> Traversable:
+    """Load `value` resource."""
+    package, _, file = value.partition(":")
+    return importlib.resources.files(package).joinpath(file)
+
+
+def copy_to_clipboard(value: str, /) -> None:
+    """Copy `value` into the clipboard."""
+    try:
+        import copykitten  # noqa: PLC0415
+    except ImportError as exc:
+        msg = "Unable to import 'copykitten', install extra 'menuet[copy]'"
+        raise RuntimeError(msg) from exc
+
+    copykitten.copy(value)
+
+
+CB_SCHEMES: dict[str, Callable[[str], Any]] = {
+    "exec": exec,
+    "ep": load_entry_point,
+    "url": webbrowser.open,
+    "copy": copy_to_clipboard,
+}
+
+ICON_SCHEMES: dict[str, Callable[[str], Traversable]] = {
+    "path": Path,
+    "res": load_resource,
+}
+
+
+def to_tuple_converter(value: Any) -> tuple[Any, ...]:  # noqa: ANN401
+    """Convert `value` into a tuple."""
+    if is_iterable(value):
+        return tuple(value)
+    return (value,)
+
+
+def is_iterable(obj: Any) -> bool:  # noqa: ANN401
+    """Returns `True` if `obj` is Iterable."""
+    if isinstance(obj, list | tuple | set | dict):
+        return True
+    return not isinstance(obj, str) and isinstance(obj, Iterable)
+
+
+def passthrough() -> None:
+    """Callable that does nothing."""
+
+
+def to_cb_converter(value: Any) -> Callable[[], Any]:  # noqa: ANN401
+    """Convert `value` to a Callable that takes no argument."""
+    if callable(value):
+        return value  # type: ignore[no-any-return]
+
+    if isinstance(value, str):
+        scheme, sep, rest = value.partition(":")
+        if not sep:
+            return partial(exec, scheme)
+        return partial(CB_SCHEMES.get(scheme, exec), rest)
+
+    raise TypeError(type(value))
+
+
+def to_icon_converter(value: Any) -> Traversable | None:  # noqa: ANN401
+    """Convert `value` to icon path."""
+    if value is None:
+        return value
+
+    if isinstance(value, Path):
+        return value
+
+    if isinstance(value, str):
+        scheme, sep, rest = value.partition(":")
+        if not sep:
+            return Path(scheme)
+
+        converter = ICON_SCHEMES[scheme]
+
+        try:
+            return converter(rest)
+        except Exception:
+            logger.exception("Failed to parse icon '%s'", value)
+            return None
+
+    raise TypeError(type(value))
+
+
+def skip_n(iterable: Iterable[_T], *, n: int = 1) -> Iterable[_T]:
+    """Drops `n` elements from the `iterable`."""
+    it = iterable.__iter__()
+    for _ in range(n):
+        next(it)
+    yield from it

menuet-1.0.0.dist-info/METADATA

@@ -0,0 +1,91 @@
+Metadata-Version: 2.4
+Name: menuet
+Version: 1.0.0
+Summary: Declarative menu builder for DCC applications
+Project-URL: Repository, https://codeberg.org/tahv/menuet
+Author: Thibaud Gambier
+License-Expression: MIT
+License-File: LICENSE
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.10
+Requires-Dist: attrs>=26.1.0
+Requires-Dist: tomli>=2.3.0; python_version < '3.11'
+Requires-Dist: typing-extensions>=4.15.0
+Provides-Extra: copy
+Requires-Dist: copykitten>=2.0.0; extra == 'copy'
+Provides-Extra: qt
+Requires-Dist: pyside6>=6.11.0; extra == 'qt'
+Description-Content-Type: text/markdown
+
+# menuet
+
+[![Source](https://img.shields.io/badge/Codeberg-%232185D0?logo=codeberg&logoColor=white)](https://codeberg.org/tahv/menuet)
+[![Documentation](https://img.shields.io/badge/Documentation-teal)](https://tahv.codeberg.page/menuet/)
+
+Menuet (`/mə.nɥɛ/`) is a declarative menu builder for DCC applications.
+
+## Features
+
+- Supports, 3ds Max, Maya, MotionBuilder and other any PySide6 application.
+- Load menu from a TOML or JSON configuration, from a dict, from entry points,
+  or build it programmatically.
+- Declare one or more menus in a dedicated `.toml` file.
+- Compose menu from multiple `.toml` files.
+- Declare a menu in a `pyproject.toml` directly.
+
+## Installation
+
+```console
+pip install menuet
+```
+
+## Usage
+
+Create a menu configuration in [TOML](https://toml.io/) format.
+
+```toml
+# menu.toml
+[[action]]
+id = "print-hello"
+label = "Print Hello"
+cb = "print('Hello')"
+group = "Some Separator"
+
+[[action]]
+id = "open-gui"
+label = "Open GUI"
+cb = "ep:myapp.gui:open_gui"
+menu = ["Foo", "Bar"]
+```
+
+Load the above configuration into a `Model` and pass
+that model to a Menu Builder to create a menu.
+
+```python
+from pathlib import Path
+from menuet.builders.text import Render, TextMenuBuilder
+from menuet.model import Model, loads
+
+model = Model()
+loads(Path("menu.toml").read_text(), model)
+
+builder = TextMenuBuilder(model, root_menu="Demo", render=Render.UTF8)
+print(builder.build())
+```
+
+```text
+Demo
+├── Foo
+│   └── Bar
+│       └── Open GUI
+├── Some Separator ───
+└── Print Hello
+```
+
+See the [documentation](https://tahv.codeberg.page/menuet/)
+for more advanced patterns.
+
+## Contributing
+
+For guidance on setting up a development environment and contributing, see
+[CONTRIBUTING.md](https://codeberg.org/tahv/menuet/src/branch/main/CONTRIBUTING.md).

menuet-1.0.0.dist-info/RECORD

@@ -0,0 +1,13 @@
+menuet/__init__.py,sha256=yScrmDmGM7uQeKA64Ot50_-wtURFN8yHcuGR0ai36V0,370
+menuet/action.py,sha256=sKDJq47Rp-MjGrenMscoLzJgim5_UVeLHGlGCFsp5HY,2543
+menuet/menu.py,sha256=XGmcH4DWtgf_E9ensAD3BwYR_wrUHadLhu4lC938pY0,1623
+menuet/model.py,sha256=A3AJlH-hh0DUZQzy68oAQ9fUk04sI901E9ixRqJfYCI,8251
+menuet/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+menuet/utils.py,sha256=wNZMslkjZ4YErb8dOqBbuU6KsUMdxlMv6kOYXxVz1-M,3180
+menuet/builders/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+menuet/builders/qt.py,sha256=rdMBi0io5FLArakC8nrdWklZ-DGHciz4tQNLJ5euVq0,3569
+menuet/builders/text.py,sha256=5OoiBNzHpGBFmeijCcyVswvIPI6Yp1njihOTg3xwH_8,3534
+menuet-1.0.0.dist-info/METADATA,sha256=zkRNeBXdGuqe-UUp7X3uzkEeJKVYVIndafFXVk56cwE,2417
+menuet-1.0.0.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+menuet-1.0.0.dist-info/licenses/LICENSE,sha256=-c8oQ0RpKfibPQPRBvKkx7AOe6Jo03v2XMC2pJfJNFI,1072
+menuet-1.0.0.dist-info/RECORD,,

menuet-1.0.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.29.0
+Root-Is-Purelib: true
+Tag: py3-none-any

menuet-1.0.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Thibaud Gambier
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.