cx-wealth 0.1.0__tar.gz

cx_wealth-0.1.0/.gitignore

@@ -0,0 +1,180 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+.python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+Pipfile.lock
+
+# UV
+#   Similar to Pipfile.lock, it is generally recommended to include uv.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+uv.lock
+
+# poetry
+#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
+poetry.lock
+
+# pdm
+#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
+#pdm.lock
+#   pdm stores project-wide configurations in .pdm.toml, but it is recommended to not include it
+#   in version control.
+#   https://pdm.fming.dev/latest/usage/project/#working-with-version-control
+.pdm.toml
+.pdm-python
+.pdm-build/
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# PyCharm
+#  JetBrains specific template is maintained in a separate JetBrains.gitignore that can
+#  be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
+#  and can be added to the global gitignore or merged into this file.  For a more nuclear
+#  option (not recommended) you can uncomment the following to ignore the entire idea folder.
+#.idea/
+
+# Ruff stuff:
+.ruff_cache/
+
+# PyPI configuration file
+.pypirc
+
+.vscode/
+.idea/
+.vs/
+
+/temp/

cx_wealth-0.1.0/PKG-INFO

@@ -0,0 +1,17 @@
+Metadata-Version: 2.4
+Name: cx-wealth
+Version: 0.1.0
+Summary: A lib of CLI gadgets extended from rich.
+Author-email: xiii_1991 <xiii_1991@163.com>
+Requires-Python: >=3.12
+Requires-Dist: rich>=14.0.0
+Description-Content-Type: text/markdown
+
+# cx_wealth
+
+## 介绍
+cx_wealth 是一个用于构建结构化命令行帮助信息和丰富终端显示的工具库。
+它基于 [Rich](https://rich.readthedocs.io) 库实现，提供优雅的样式化输出、模块化参数管理以及可扩展的详细信息面板，
+适用于需要复杂命令行界面的工具和应用程序。
+
+## 常用组件

cx_wealth-0.1.0/README.md

@@ -0,0 +1,8 @@
+# cx_wealth
+
+## 介绍
+cx_wealth 是一个用于构建结构化命令行帮助信息和丰富终端显示的工具库。
+它基于 [Rich](https://rich.readthedocs.io) 库实现，提供优雅的样式化输出、模块化参数管理以及可扩展的详细信息面板，
+适用于需要复杂命令行界面的工具和应用程序。
+
+## 常用组件

cx_wealth-0.1.0/cx_wealth/__init__.py

@@ -0,0 +1,6 @@
+from .common import *
+from .dynamic_columns import *
+from .indexed_list_panel import *
+from .wealth_detail import *
+from .wealth_help import *
+from .wealth_label import *

cx_wealth-0.1.0/cx_wealth/common.py

@@ -0,0 +1,6 @@
+from typing import Protocol, runtime_checkable
+
+
+@runtime_checkable
+class RichPrettyMixin(Protocol):
+    def __rich_repr__(self): ...

cx_wealth-0.1.0/cx_wealth/dynamic_columns.py

@@ -0,0 +1,44 @@
+from collections.abc import Sequence, Iterable, Generator
+
+from . import rich_types as r
+
+
+class DynamicColumns:
+    """动态列渲染器，根据终端宽度自动调整列数和列宽。
+
+    将一组渲染对象按列布局显示，最多显示指定的最大列数。当对象数量超过最大列数时，
+    每列宽度会根据终端宽度平均分配；若对象数量不足，则按单列自适应显示。支持扩展填充终端可用空间。
+
+    Args:
+        renderables (Sequence | Iterable): 要渲染的对象集合。
+        max_columns (int, optional): 允许的最大列数，默认为2。
+        expand (bool, optional): 是否扩展填充终端宽度，默认为True。
+    """
+
+    def __init__(
+        self, renderables: Sequence | Iterable, max_columns: int = 2, expand=True
+    ):
+        self._renderables = list(renderables)
+        self._max_columns = max_columns
+        self._expand = expand
+
+    def __rich_console__(
+        self, console: r.Console, _options: r.ConsoleOptions
+    ) -> "Generator[r.RenderableType, None, None]":
+        """Rich库渲染钩子，生成列式布局的渲染对象。
+
+        Args:
+            console (rich.Console): 当前控制台实例。
+            _options (rich.ConsoleOptions): 渲染选项（未使用）。
+
+        Yields:
+            rich.Columns: 根据终端宽度计算后的列式布局对象。
+        """
+        w = (
+            None
+            if len(self._renderables) < self._max_columns
+            else int(console.width / self._max_columns) - 1
+        )
+        yield r.Columns(
+            self._renderables, expand=self._expand, equal=True, width=w
+        )

cx_wealth-0.1.0/cx_wealth/indexed_list_panel.py

@@ -0,0 +1,118 @@
+from collections.abc import Sequence, Iterable
+
+from . import rich_types as r
+
+
+class IndexedListPanel:
+    """索引列表面板，用于在终端中以带索引的表格形式显示列表内容。
+
+    功能特点：
+    - 索引编号右对齐并绿色高亮显示
+    - 支持设置起始索引（默认1）
+    - 提供最大显示行数控制，超过时显示省略提示
+    - 自动计算索引宽度适配最大值位数
+    - 自带面板封装，显示项数统计信息
+    - 支持边框样式定制（使用Rich样式语法）
+
+    该组件基于Rich库的Table和Panel组件实现，适用于命令行工具的列表展示场景。
+    """
+    
+    def __init__(
+        self,
+        items: Sequence | Iterable,
+        title: str | None = None,
+        start_index: int = 1,
+        max_lines: int = 20,
+        border_style: r.StyleType | None = None,
+    ):
+        """初始化索引列表面板
+
+        Args:
+            items (Sequence | Iterable): 待展示的列表数据源
+            title (str, optional): 面板标题. Defaults to None.
+            start_index (int, optional): 索引起始值，默认从1开始. Defaults to 1.
+            max_lines (int, optional): 最大显示行数，超过时截断并提示剩余项数. Defaults to 20.
+            border_style (rich.StyleType, optional): 边框样式，支持Rich样式名称或对象. Defaults to "none".
+        """
+        self._items = list(items)
+        self._title = title
+        self._start_index = start_index
+        self._max_lines = max_lines
+        self._border_style = border_style or "none"
+
+    @staticmethod
+    def default_width_calculator(console: r.Console) -> int:
+        """计算默认表格宽度（占终端宽度的80%）
+
+        Args:
+            console (rich.Console): 当前控制台实例
+
+        Returns:
+            int: 计算后的宽度值
+        """
+        return int(console.width * 0.8)
+
+    @staticmethod
+    def __check_item(item) -> r.RenderableType:
+        """验证并适配项的渲染格式
+
+        Args:
+            item (Any): 待检查的项内容
+
+        Returns:
+            rich.RenderableType: 可渲染对象（不可渲染时转为字符串）
+        """
+        if r.protocol.is_renderable(item):
+            return item
+        return str(item)
+
+    def get_table(self) -> r.Table:
+        """生成带索引的表格对象
+
+        Returns:
+            rich.Table: 包含索引列和内容列的表格对象
+        """
+        table = r.Table(show_header=False, box=None)
+        table.add_column("index", justify="right", style="green", ratio=1)
+        table.add_column(
+            "content",
+            justify="left",
+            highlight=True,
+            overflow="fold",
+            ratio=200,
+        )
+
+        total = len(self._items)
+        total_digits = len(str(total))
+
+        for i, item in enumerate(self._items, start=self._start_index):
+            if self._max_lines and i > self._max_lines:
+                table.add_row(
+                    f"[red][{'.'*total_digits}][/]",
+                    f"[italic red]skipped {total - i -1} items...[/]",
+                )
+                table.add_row(f"[{total}]", self.__check_item(self._items[-1]))
+                break
+            table.add_row(
+                f"[{i:>{total_digits}}]",
+                self.__check_item(item),
+            )
+
+        return table
+
+    def __rich__(self) -> r.Panel:
+        """Rich库渲染钩子，返回封装好的面板对象
+
+        Returns:
+            rich.Panel: 包含表格或空提示的面板
+        """
+        content = self.get_table() if self._items else r.Text("(empty)", style="dim")
+        total = len(self._items)
+        return r.Panel(
+            content,
+            title=self._title,
+            subtitle=f"{total} items",
+            title_align="left",
+            subtitle_align="right",
+            border_style=self._border_style,
+        )

cx_wealth-0.1.0/cx_wealth/rich_types.py

@@ -0,0 +1,78 @@
+import rich.text
+
+Text = rich.text.Text
+
+import rich.console
+
+Console = rich.console.Console
+ConsoleOptions = rich.console.ConsoleOptions
+Group = rich.console.Group
+group = rich.console.group
+RenderableType = rich.console.RenderableType
+NewLine = rich.console.NewLine
+
+import rich.segment
+
+Segment = rich.segment.Segment
+
+import rich.panel
+
+Panel = rich.panel.Panel
+
+import rich.theme
+
+Theme = rich.theme.Theme
+
+import rich.columns
+
+Columns = rich.columns.Columns
+
+import rich.markup
+
+markup = rich.markup
+
+import rich.markdown
+
+Markdown = rich.markdown.Markdown
+
+
+import rich.pretty
+
+Pretty = rich.pretty.Pretty
+
+
+import rich.table
+
+Table = rich.table.Table
+Column = rich.table.Column
+
+import rich.style
+
+Style = rich.style.Style
+StyleType = rich.style.StyleType
+
+import rich.padding
+
+Padding = rich.padding.Padding
+
+import rich.protocol
+
+protocol = rich.protocol
+
+import rich.align
+
+Align = rich.align.Align
+
+import rich.measure
+
+Measurement = rich.measure.Measurement
+
+import rich.progress
+
+Progress = rich.progress.Progress
+TaskID = rich.progress.TaskID
+SpinnerColumn = rich.progress.SpinnerColumn
+TextColumn = rich.progress.TextColumn
+BarColumn = rich.progress.BarColumn
+TaskProgressColumn = rich.progress.TaskProgressColumn
+TimeRemainingColumn = rich.progress.TimeRemainingColumn

cx_wealth-0.1.0/cx_wealth/wealth_detail.py

@@ -0,0 +1,138 @@
+from collections.abc import Generator
+from typing import Iterable, Mapping, Protocol, Sequence, runtime_checkable
+
+from rich.console import (
+    RenderableType,
+)
+
+from . import rich_types as r
+from .common import RichPrettyMixin
+from .indexed_list_panel import IndexedListPanel
+from .wealth_label import WealthLabel, WealthLabelMixin
+
+
+@runtime_checkable
+class WealthDetailMixin(Protocol):
+    def __rich_detail__(self) -> Generator: ...
+
+
+class WealthDetail:
+    def __init__(self, item: WealthDetailMixin):
+        self._item = item
+
+    def __rich_repr__(self):
+        yield from self._item.__rich_detail__()
+
+
+class WealthDetailTable:
+    _SUB_BOX_BORDER_STYLE = "grey70"
+
+    def __init__(
+        self,
+        item: WealthDetailMixin | RichPrettyMixin | Mapping | dict,
+        sub_box: bool = True,
+    ) -> None:
+        self._item = item
+        self._sub_box = sub_box
+
+    def make_table(self, item):
+        table = r.Table(
+            show_header=False,
+            box=None,
+        )
+        table.add_column("key", justify="left", style="italic yellow", no_wrap=True)
+        table.add_column("value", justify="left", overflow="fold", highlight=True)
+
+        iterator = None
+        if isinstance(item, WealthDetailMixin):
+            iterator = item.__rich_detail__()
+        elif isinstance(item, RichPrettyMixin):
+            iterator = item.__rich_repr__()
+        elif isinstance(item, Mapping | dict):
+            iterator = item.items()
+        elif isinstance(item, Iterable):
+            iterator = [None, list(item)]
+
+        if iterator is None:
+            return table
+
+        for tup in iterator:
+            if not isinstance(tup, tuple):
+                continue
+            key, value = None, None
+            match len(tup):
+                case 0:
+                    continue
+                case 1:
+                    value = tup[0]
+                case 2:
+                    key, value = tup
+                case _:
+                    key, *values = tup
+                    value = list(values)
+            table.add_row(key, self.__check_value(value))
+
+        if table.row_count == 0:
+            return r.Text("(empty)", style="dim yellow")
+        return table
+
+    def __check_value(
+        self, value, disable_sub_box: bool = False
+    ) -> RenderableType | None:
+        if value is None:
+            return None
+        if isinstance(value, Mapping | dict | WealthDetailMixin | RichPrettyMixin):
+            if self._sub_box and not disable_sub_box:
+                return WealthDetailPanel(
+                    value,
+                    border_style=self._SUB_BOX_BORDER_STYLE,
+                    sub_box=False,
+                    title=value.__class__.__name__,
+                )
+            return self.make_table(value)
+        if isinstance(value, WealthLabelMixin):
+            return WealthLabel(value)
+        if isinstance(value, RenderableType):
+            return value
+        if isinstance(value, Sequence | Iterable):
+            list_panel = IndexedListPanel(
+                list(self.__check_value(v, disable_sub_box=True) for v in value),
+                title=value.__class__.__name__,
+                border_style=self._SUB_BOX_BORDER_STYLE,
+                start_index=0,
+            )
+            if self._sub_box and not disable_sub_box:
+                return list_panel
+            return list_panel.get_table()
+        return r.Pretty(value)
+
+    def __rich__(self):
+        return self.make_table(self._item)
+
+
+class WealthDetailPanel:
+    def __init__(
+        self,
+        item: WealthDetailMixin | RichPrettyMixin | Mapping | dict,
+        title: str | None = None,
+        border_style: r.StyleType | None = None,
+        sub_box: bool = True,
+    ):
+        self._item = item
+        self._title = title
+        self._border_style = border_style or "none"
+        self._sub_box = sub_box
+
+    def __rich__(self):
+        content = WealthDetailTable(self._item, sub_box=self._sub_box)
+
+        panel = r.Panel(
+            content,
+            title=self._title,
+            subtitle=self._item.__class__.__name__,
+            title_align="left",
+            subtitle_align="right",
+            expand=True,
+            border_style=self._border_style,
+        )
+        return panel

cx_wealth-0.1.0/cx_wealth/wealth_help/__init__.py

@@ -0,0 +1 @@
+from .w_help import WealthHelp

cx_wealth-0.1.0/cx_wealth/wealth_help/_action.py

@@ -0,0 +1,149 @@
+import re
+from typing import Literal, override
+
+from ._node import _Node
+from .. import rich_types as r
+
+
+_ActionNargs = Literal["?", "+", "*", "**"]
+
+
+class _Action(_Node):
+
+    def __init__(
+        self,
+        *flags,
+        name: str | None = None,
+        description: str | None = None,
+        metavar: str | None = None,
+        nargs: int | _ActionNargs | None = None,
+        optional: bool | None = None,
+        parent: _Node | None = None,
+    ) -> None:
+        super().__init__(name=name, description=description, parent=parent)
+        self.flags = [str(x) for x in flags]
+        self.metavar = metavar
+        self.nargs = nargs
+        self.optional = optional
+
+    def _argument(self):
+        return (
+            self.metavar
+            or (self.flags[0] if self.flags and self.is_positional() else None)
+            or self.name
+            or ""
+        )
+
+    def _format_argument(self, pattern: str | None = None) -> r.Text:
+        a = self._argument() if pattern is None else pattern.format(self._argument())
+        return r.Text(a, style="cx.help.usage.argument")
+
+    def is_positional(self) -> bool:
+        return not self.flags or all(not re.match(r"^[-+]+\w+", x) for x in self.flags)
+
+    def is_optional(self) -> bool:
+        if self.optional is not None:
+            return self.optional
+
+        return not self.is_positional() or self.nargs == "?"
+
+    @staticmethod
+    def _format_option(option: str) -> r.Text:
+        return r.Text(option, style="cx.help.usage.option")
+
+    @staticmethod
+    def _make_optional(*text: r.Text | str | None) -> r.Text:
+        left = ("[", "cx.help.usage.bracket")
+        right = ("]", "cx.help.usage.bracket")
+        ts = [
+            x if isinstance(x, r.Text) else r.Text.from_markup(x)
+            for x in text
+            if x is not None
+        ]
+        return r.Text.assemble(left, *ts, right)
+
+    def render_options(self, sep: str = "|") -> r.Text | None:
+        if not self.flags:
+            return None
+
+        elements = [self._format_option(x) for x in self.flags]
+        separator = r.Text(sep, style="cx.help.usage.bracket")
+        return separator.join(elements)
+
+    def render_argument(self) -> r.Text | None:
+        if not self._argument():
+            return None
+
+        if isinstance(self.nargs, int):
+            args = [
+                self._format_argument(pattern="{}" + str(i + 1))
+                for i in range(self.nargs)
+            ]
+            sep = r.Text(", ", style="cx.help.usage.bracket")
+            return sep.join(args)
+
+        sep = r.Text(", ", style="cx.help.usage.bracket")
+
+        if self.nargs == "+":
+            args = [
+                self._format_argument(pattern="{}1"),
+                self._make_optional(sep, self._format_argument(pattern="{}2")),
+                self._make_optional(sep, self._format_argument(pattern="{}3")),
+                self._make_optional(sep, self._format_argument(pattern="{}...")),
+            ]
+            return r.Text.assemble(*args)
+
+        if self.nargs == "*":
+            args = [
+                self._make_optional(self._format_argument(pattern="{}1")),
+                self._make_optional(sep, self._format_argument(pattern="{}2")),
+                self._make_optional(sep, self._format_argument(pattern="{}3")),
+                self._make_optional(sep, self._format_argument(pattern="{}...")),
+            ]
+            return r.Text.assemble(*args)
+
+        return self._format_argument()
+
+    @override
+    def render_usage(self) -> r.Text:
+        res = r.Text()
+        if self.is_positional():
+            res = self.render_argument() or res
+        else:
+            ps = [self.render_options(), self.render_argument()]
+            res = r.Text(" ").join([x for x in ps if x is not None])
+
+        if self.nargs == "**":
+            res = r.Text.assemble(
+                self._make_optional(res),
+                self._make_optional(
+                    self.render_options(),
+                    r.Text(" ...", style="cx.help.usage.argument"),
+                ),
+            )
+
+        if self.is_optional():
+            res = self._make_optional(res)
+
+        return res
+
+    def render_detail_title(self):
+        res = r.Text()
+        if self.is_positional():
+            res = self.render_argument() or res
+        else:
+            ps = [self.render_options(","), self.render_argument()]
+            res = r.Text(" ").join([x for x in ps if x is not None])
+        return res
+
+    @override
+    @r.group(True)
+    def render_details(self):
+        yield self.render_detail_title()
+        if self.description:
+            yield r.Padding(
+                r.Text.from_markup(
+                    self.description, style="cx.help.details.description"
+                ),
+                pad=(0, 0, 0, 4),
+            )

cx_wealth-0.1.0/cx_wealth/wealth_help/_group.py

@@ -0,0 +1,78 @@
+from __future__ import annotations
+
+from collections.abc import Generator
+from typing import Literal
+from typing import override
+
+from cx_wealth.rich_types import Text
+from ._action import _Action, _ActionNargs
+from ._node import _Node
+from .. import rich_types as r
+
+
+class _Group(_Node):
+    def __init__(
+        self,
+        name: str | None = None,
+        description: str | None = None,
+        parent: _Node | None = None,
+    ) -> None:
+        super().__init__(name, description, parent)
+
+    def add_action(
+        self,
+        *flags,
+        name: str | None = None,
+        description: str | None = None,
+        metavar: str | None = None,
+        nargs: int | _ActionNargs | None = None,
+        optional: bool | None = None,
+    ) -> _Action:
+        action = _Action(
+            *flags,
+            name=name,
+            description=description,
+            metavar=metavar,
+            nargs=nargs,
+            optional=optional,
+            parent=self,
+        )
+        return action
+
+    def add_group(
+        self,
+        name: str | None = None,
+        description: str | None = None,
+    ) -> _Group:
+        group = _Group(name, description, self)
+        return group
+
+    def iter_actions(self) -> Generator[_Action, None, None]:
+        for action in self.children:
+            if isinstance(action, _Action):
+                yield action
+            elif isinstance(action, _Group):
+                yield from action.iter_actions()
+
+    @override
+    def render_usage(self) -> Text:
+        usages = [x.render_usage() for x in self.iter_actions()]
+        return r.Text(" ").join(usages)
+
+    @override
+    @r.group(True)
+    def render_details(self):
+        if self.name:
+            yield r.Padding(
+                r.Text(self.name, style="cx.help.group.title"), pad=(1, 0, 0, 0)
+            )
+        if self.description:
+            yield r.Padding(
+                r.Text(
+                    self.description, style="cx.help.group.description", overflow="fold"
+                ),
+                pad=(0, 0, 0, 2),
+            )
+        for child in self.children:
+            p = r.Padding(child.render_details(), (0, 0, 1, child.level))
+            yield p

cx_wealth-0.1.0/cx_wealth/wealth_help/_node.py

@@ -0,0 +1,43 @@
+from __future__ import annotations
+
+from typing import Self
+
+from .. import rich_types as r
+
+
+class _Node:
+    def __init__(
+        self,
+        name: str | None = None,
+        description: str | None = None,
+        parent: _Node | None = None,
+    ) -> None:
+        self.name = name
+        self.description = description
+        self.children: list[_Node] = []
+        self.parent: _Node | None = None
+        self._set_parent(parent)
+
+    def _set_parent(self, parent: _Node | None):
+        if self.parent is not None:
+            self.parent.children.remove(self)
+        self.parent = parent
+        if parent is not None and self not in parent.children:
+            parent.children.append(self)
+
+    def add_node(self, node: _Node) -> Self:
+        node._set_parent(self)
+        return self
+
+    def __iter__(self):
+        yield from self.children
+
+    @property
+    def level(self) -> int:
+        return self.parent.level + 1 if self.parent is not None else 0
+
+    def render_usage(self) -> r.Text:
+        return r.Text(" ").join(x.render_usage() for x in self.children)
+
+    def render_details(self) -> r.RenderableType:
+        return r.Group(*(x.render_details() for x in self.children))

cx_wealth-0.1.0/cx_wealth/wealth_help/w_help.py

@@ -0,0 +1,150 @@
+import itertools
+import sys
+from typing import Literal
+from collections.abc import Iterable
+from ._action import _Action, _ActionNargs
+from ._group import _Group
+from .. import rich_types as r
+
+
+class WealthHelp:
+    DEFAULT_STYLES = {
+        "cx.help.usage.title": "green",
+        "cx.help.usage.prog": "orange1",
+        "cx.help.usage.bracket": "bright_black",
+        "cx.help.usage.option": "cyan",
+        "cx.help.usage.argument": "italic yellow",
+        "cx.help.group.title": "orange1",
+        "cx.help.group.description": "italic dim default",
+        "cx.help.details.box": "blue",
+        "cx.help.details.description": "italic default",
+        "cx.help.epilog": "dim italic default",
+    }
+
+    def __init__(
+        self,
+        prog: str | None = None,
+        description: str | r.RenderableType | None = None,
+        epilog: str | r.RenderableType | None = None,
+        styles: dict | None = None,
+    ):
+        self.prog = prog or sys.argv[0]
+        self.description = description
+        self._root = _Group()
+        self.styles = self.DEFAULT_STYLES
+        self.epilog = epilog
+        if styles is not None:
+            self.styles.update(styles)
+        self.theme = r.Theme(self.styles)
+
+    def add_action(
+        self,
+        *flags,
+        name: str | None = None,
+        description: str | None = None,
+        metavar: str | None = None,
+        nargs: int | _ActionNargs | None = None,
+        optional: bool | None = None,
+    ) -> _Action:
+        return self._root.add_action(
+            *flags,
+            name=name,
+            description=description,
+            metavar=metavar,
+            nargs=nargs,
+            optional=optional,
+        )
+
+    def add_group(
+        self,
+        name: str | None = None,
+        description: str | None = None,
+    ) -> _Group:
+        return self._root.add_group(name=name, description=description)
+
+    def render_description(self) -> r.RenderableType | None:
+        if isinstance(self.description, str):
+            desc = r.Text.from_markup(
+                self.description, style="cx.help.group.description"
+            )
+            # desc.no_wrap = True
+            desc.overflow = "fold"
+        elif isinstance(self.description, r.RenderableType):
+            desc = self.description
+        else:
+            return None
+
+        return (
+            r.Padding(
+                desc,
+                (1, 1, 0, 1),
+            )
+            if self.description
+            else None
+        )
+
+    def render_epilog(self) -> r.RenderableType | None:
+        if isinstance(self.epilog, str):
+            return r.Text.from_markup(
+                self.epilog, style="cx.help.epilog", justify="right"
+            )
+        if isinstance(self.epilog, r.RenderableType):
+            return self.epilog
+        return None
+
+    def render_usage(self) -> r.RenderableType:
+        def separate(x: _Action):
+            a = "o" if x.is_optional() else ""
+            b = "+p" if x.is_positional() else "-p"
+            return a + b
+
+        grouped_actions = {
+            k: list(v)
+            for k, v in itertools.groupby(self._root.iter_actions(), key=separate)
+        }
+
+        usages = [
+            x.render_usage()
+            for x in itertools.chain(
+                *(grouped_actions.get(x, []) for x in ["o-p", "-p", "o+p", "+p"])
+            )
+        ]
+        usage = r.Text(" ").join(usages)
+
+        program = r.Text(self.prog, style="cx.help.usage.prog")
+        table = r.Table(box=None, show_header=False, expand=True)
+        table.add_column("prog", no_wrap=True, overflow="ignore")
+        table.add_column("usage", overflow="fold")
+        table.add_row(program, usage)
+
+        desc = self.render_description()
+
+        return r.Panel(
+            r.Group(table, desc) if desc else table,
+            title="用法",
+            expand=True,
+            title_align="left",
+            style="cx.help.usage.title",
+        )
+
+    def render_details(self) -> r.RenderableType:
+        details = [x.render_details() for x in self._root.children]
+        return r.Panel(
+            r.Group(*details),
+            title="参数详情",
+            expand=True,
+            title_align="left",
+            style="cx.help.details.box",
+        )
+
+    def render(self) -> Iterable[r.RenderableType]:
+        yield self.render_usage()
+        yield self.render_details()
+        r_epilog = self.render_epilog()
+        if r_epilog:
+            yield r_epilog
+
+    def __rich_console__(self, console: r.Console, options: r.ConsoleOptions):
+        with console.use_theme(self.theme):
+            o = options.update(highlight=False)
+            yield from console.render(r.Group(*self.render(), fit=True), o)

cx_wealth-0.1.0/cx_wealth/wealth_label.py

@@ -0,0 +1,63 @@
+from collections.abc import Generator
+from typing import Literal
+from typing import Protocol, runtime_checkable
+
+from cx_studio.utils import FunctionalUtils
+from . import rich_types as r
+
+
+@runtime_checkable
+class WealthLabelMixin(Protocol):
+    def __rich_label__(self) -> Generator: ...
+
+
+class WealthLabel:
+    def __init__(
+        self,
+        obj: WealthLabelMixin,
+        markup=True,
+        sep: str = " ",
+        tab_size: int = 1,
+        overflow: Literal["ignore", "crop", "ellipsis", "fold"] = "crop",
+        justify: Literal["left", "center", "right"] = "left",
+    ):
+        self._obj = obj
+        self._markup = markup
+        self._tab_size = tab_size
+        self._sep = sep
+        self._overflow: Literal["ignore", "crop", "ellipsis", "fold"] = overflow
+        self._justify: Literal["left", "center", "right"] = justify
+
+    def __unpack_item(self, item):
+        if isinstance(item, WealthLabelMixin):
+            for x in item.__rich_label__():
+                yield from self.__unpack_item(x)
+        elif isinstance(item, WealthLabel):
+            yield from self.__unpack_item(item._obj)
+        elif isinstance(item, str):
+            yield r.Text.from_markup(item) if self._markup else r.markup.escape(item)
+        elif isinstance(item, r.Text):
+            yield item
+        elif isinstance(item, r.Segment):
+            yield item.text
+            if item.style:
+                yield item.style
+        else:
+            yield str(item)
+
+    def __rich__(self):
+        if not isinstance(self._obj, WealthLabelMixin):
+            cls_name = self._obj.__class__.__name__
+            return r.Pretty(f"[{cls_name}] (instance)")
+
+        elements = self.__unpack_item(self._obj)
+        elements_with_sep = list(
+            FunctionalUtils.iter_with_separator(elements, self._sep)
+        )
+        text = r.Text.assemble(
+            *elements_with_sep,  # type:ignore
+            tab_size=self._tab_size,
+            overflow=self._overflow,
+            justify=self._justify,
+        )
+        return text

cx_wealth-0.1.0/pyproject.toml

@@ -0,0 +1,19 @@
+[project]
+name = "cx-wealth"
+version = "0.1.0"
+description = "A lib of CLI gadgets extended from rich."
+readme = "README.md"
+authors = [
+    { name = "xiii_1991", email = "xiii_1991@163.com" }
+]
+requires-python = ">=3.12"
+dependencies = [
+    "rich>=14.0.0",
+]
+
+[project.scripts]
+cx-wealth = "cx_wealth:main"
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"