rich-objects 0.1.0__tar.gz

rich_objects-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Rick Porter
+
+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.

rich_objects-0.1.0/PKG-INFO

@@ -0,0 +1,150 @@
+Metadata-Version: 2.4
+Name: rich-objects
+Version: 0.1.0
+Summary: 
+License-File: LICENSE
+Author: Rick Porter
+Author-email: rickwporter@gmail.com
+Requires-Python: >=3.10
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Topic :: Software Development
+Classifier: Topic :: Software Development :: Libraries
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Typing :: Typed
+Classifier: Topic :: Utilities
+Requires-Dist: pyyaml (>=6.0.3,<7.0.0)
+Requires-Dist: rich (>=14.2.0,<15.0.0)
+Description-Content-Type: text/markdown
+
+# openapi-spec-tools
+
+This is a small set of tools to help provide easy to use, flexible tools for display complex objects for a CLI.
+
+## Getting started
+
+The project has been published to PyPi, so you should be able to install it with something like one of the following (depending on how you do Python package management):
+```terminal
+% pip install rich-objects
+% poetry add rich-objects
+```
+
+The sections below provide a brief description with links to more examples and details.
+
+## Background
+
+This module extends the [rich](https://github.com/Textualize/rich) module to provide pretty printing of complex data objects. The most common use case is a CLI that displays the json/yaml data that is returned to a CLI client in several different formats.
+
+The easiest way to leverage this library is using the `display()` function. You can provide a `fmt` and `style` to provide different means of displaying the data.
+
+
+Here are some of the lower level elements:
+* `OutputFormat` and `OutputSyle` are enums suitable to use as a CLI argument to support different displays
+* `RichTable` class is a thin wrapper derived from `rich.Table`. It contains some default formatting for the tables, since it becomes confusing when tables are nested.
+* Added several functions starting with `rich_table_factory()` to create a `RichTable` with appropriate nesting based on the data returned by the data in the object.
+* The `console_factory()` is the default means for printing the output, but this just sets the `rich.Console` width.
+
+
+## Examples
+
+In general, this can be used in any enviroment where CLI output is used. 
+
+### Typer Example
+
+Here's a simple Python example to leverage the new code:
+```Python
+#!/usr/bin/env python3
+from typer import Typer
+from rich_objects import OutputFormat, display
+
+DATA = [
+    {"name": "sna", "prop1": 1, "prop B": None, "blah": "zay"},
+    {
+        "name": "foo",
+        "prop2": 2,
+        "prop B": True,
+    },
+    {
+        "name": "bar",
+        1: "inverse",
+    },
+]
+
+app = Typer()
+
+@app.command()
+def print_data(
+    output_fmt: OutputFormat = OutputFormat.TEXT,
+    output_style: OutputStyle = OutputStyle.ALL,
+    indent: int = 2,
+):
+    data = DATA  # TODO: figure out how to get your data here
+    display(data, fmt=output_fmt, style=output_style, indent=indent)
+
+if __name__ == "__main__":
+    app()
+```
+
+Here's some sample output:
+```shell
+(.venv) > ./example.py
+┏━━━━━━┳━━━━━━━━━━━━━━━━┓
+┃ Name ┃ Properties     ┃
+┡━━━━━━╇━━━━━━━━━━━━━━━━┩
+│ sna  │  prop1   1     │
+│      │  prop B  None  │
+│      │  blah    zay   │
+├──────┼────────────────┤
+│ foo  │  prop2   2     │
+│      │  prop B  True  │
+├──────┼────────────────┤
+│ bar  │  1  inverse    │
+└──────┴────────────────┘
+Found 3 items            
+(.venv) > ./example.py --output-fmt json
+[
+  {
+    "name": "sna",
+    "prop1": 1,
+    "prop B": null,
+    "blah": "zay"
+  },
+  {
+    "name": "foo",
+    "prop2": 2,
+    "prop B": true
+  },
+  {
+    "name": "bar",
+    "1": "inverse"
+  }
+]
+(.venv) > ./example.py --output-fmt yaml
+- blah: zay
+  name: sna
+  prop B: null
+  prop1: 1
+- name: foo
+  prop B: true
+  prop2: 2
+- name: bar
+  1: inverse
+
+(.venv) > 
+```
+
+
+## Contributing
+
+This project is just getting going... More development instructions will be added later. If you have any suggestions, please email Rick directly (rickwporter@gmail.com).
+

rich_objects-0.1.0/README.md

@@ -0,0 +1,120 @@
+# openapi-spec-tools
+
+This is a small set of tools to help provide easy to use, flexible tools for display complex objects for a CLI.
+
+## Getting started
+
+The project has been published to PyPi, so you should be able to install it with something like one of the following (depending on how you do Python package management):
+```terminal
+% pip install rich-objects
+% poetry add rich-objects
+```
+
+The sections below provide a brief description with links to more examples and details.
+
+## Background
+
+This module extends the [rich](https://github.com/Textualize/rich) module to provide pretty printing of complex data objects. The most common use case is a CLI that displays the json/yaml data that is returned to a CLI client in several different formats.
+
+The easiest way to leverage this library is using the `display()` function. You can provide a `fmt` and `style` to provide different means of displaying the data.
+
+
+Here are some of the lower level elements:
+* `OutputFormat` and `OutputSyle` are enums suitable to use as a CLI argument to support different displays
+* `RichTable` class is a thin wrapper derived from `rich.Table`. It contains some default formatting for the tables, since it becomes confusing when tables are nested.
+* Added several functions starting with `rich_table_factory()` to create a `RichTable` with appropriate nesting based on the data returned by the data in the object.
+* The `console_factory()` is the default means for printing the output, but this just sets the `rich.Console` width.
+
+
+## Examples
+
+In general, this can be used in any enviroment where CLI output is used. 
+
+### Typer Example
+
+Here's a simple Python example to leverage the new code:
+```Python
+#!/usr/bin/env python3
+from typer import Typer
+from rich_objects import OutputFormat, display
+
+DATA = [
+    {"name": "sna", "prop1": 1, "prop B": None, "blah": "zay"},
+    {
+        "name": "foo",
+        "prop2": 2,
+        "prop B": True,
+    },
+    {
+        "name": "bar",
+        1: "inverse",
+    },
+]
+
+app = Typer()
+
+@app.command()
+def print_data(
+    output_fmt: OutputFormat = OutputFormat.TEXT,
+    output_style: OutputStyle = OutputStyle.ALL,
+    indent: int = 2,
+):
+    data = DATA  # TODO: figure out how to get your data here
+    display(data, fmt=output_fmt, style=output_style, indent=indent)
+
+if __name__ == "__main__":
+    app()
+```
+
+Here's some sample output:
+```shell
+(.venv) > ./example.py
+┏━━━━━━┳━━━━━━━━━━━━━━━━┓
+┃ Name ┃ Properties     ┃
+┡━━━━━━╇━━━━━━━━━━━━━━━━┩
+│ sna  │  prop1   1     │
+│      │  prop B  None  │
+│      │  blah    zay   │
+├──────┼────────────────┤
+│ foo  │  prop2   2     │
+│      │  prop B  True  │
+├──────┼────────────────┤
+│ bar  │  1  inverse    │
+└──────┴────────────────┘
+Found 3 items            
+(.venv) > ./example.py --output-fmt json
+[
+  {
+    "name": "sna",
+    "prop1": 1,
+    "prop B": null,
+    "blah": "zay"
+  },
+  {
+    "name": "foo",
+    "prop2": 2,
+    "prop B": true
+  },
+  {
+    "name": "bar",
+    "1": "inverse"
+  }
+]
+(.venv) > ./example.py --output-fmt yaml
+- blah: zay
+  name: sna
+  prop B: null
+  prop1: 1
+- name: foo
+  prop B: true
+  prop2: 2
+- name: bar
+  1: inverse
+
+(.venv) > 
+```
+
+
+## Contributing
+
+This project is just getting going... More development instructions will be added later. If you have any suggestions, please email Rick directly (rickwporter@gmail.com).

rich_objects-0.1.0/pyproject.toml

@@ -0,0 +1,97 @@
+[project]
+name = "rich-objects"
+version = "0.1.0"
+description = ""
+authors = [
+    {name = "Rick Porter",email = "rickwporter@gmail.com"}
+]
+readme = "README.md"
+requires-python = ">=3.10"
+dependencies = [
+    "rich (>=14.2.0,<15.0.0)",
+    "pyyaml (>=6.0.3,<7.0.0)"
+]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Environment :: Console",
+    "Intended Audience :: Developers",
+    "Operating System :: OS Independent",
+    "Programming Language :: Python",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3 :: Only",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Programming Language :: Python :: 3.14",
+    "Topic :: Software Development",
+    "Topic :: Software Development :: Libraries",
+    "Topic :: Software Development :: Libraries :: Python Modules",
+    "Typing :: Typed",
+    "Topic :: Utilities",
+]
+
+
+[build-system]
+requires = ["poetry-core>=2.0.0,<3.0.0"]
+build-backend = "poetry.core.masonry.api"
+
+[tool.poetry.group.dev.dependencies]
+ruff = "^0.14.9"
+pytest = "^9.0.2"
+coverage = "^7.13.0"
+
+[tool.ruff]
+line-length = 120
+target-version = "py312"
+
+[tool.ruff.lint]
+select = [
+    "D",  # pydocstyle
+    "E",  # pycodestyle errors
+    "F",  # pyflakes
+    "I",  # isort
+    "W",  # pycodestyle warnings
+    "B",  # flake8-bugbear
+    "PL",  # pylint
+    "C4",  # flake8-comprehensions
+    "N",  # PEP8 naming conventions
+]
+fixable = [
+    "D", "E", "I", "W",
+]
+ignore = [
+    "PLR1711",  # "useless" returns make the code more readable
+]
+
+[tool.ruff.lint.per-file-ignores]
+# ignore the unused imports in init
+"__init__.py" = ["F401"]
+"tests/*" = [
+    "D",  # no need for docstrings on tests
+    "PLR2004",  # magic numbers allowed in tests
+]
+
+[tool.ruff.lint.isort]
+force-single-line = true
+split-on-trailing-comma = true
+
+[tool.ruff.lint.pylint]
+max-args = 25
+max-branches = 12
+max-returns = 10
+max-statements = 75
+
+[tool.coverage.run]
+data_file = ".coverage"
+source = [
+    "rich_objects",
+]
+
+[tool.coverage.report]
+exclude_lines = [
+    "pragma: no cover",
+    "@overload",
+    'if __name__ == "__main__":',
+]
+

rich_objects-0.1.0/rich_objects/__init__.py

@@ -0,0 +1,9 @@
+"""Module for rich display of complex objects (e.g. JSON/dict)."""
+
+from rich_objects.console import console_factory
+from rich_objects.display import display
+from rich_objects.display import rich_table_factory
+from rich_objects.enums import OutputFormat
+from rich_objects.enums import OutputStyle
+from rich_objects.rich_table import RichTable
+from rich_objects.table_config import TableConfig

rich_objects-0.1.0/rich_objects/console.py

@@ -0,0 +1,24 @@
+"""Module containing a factory for generating a rich Console."""
+import os
+
+from rich.console import Console
+
+TEST_TERMINAL_WIDTH = 100
+
+
+def console_factory(*args, **kwargs) -> Console:
+    """Create/initialize a Console object.
+
+    A little hacky here... Allow terminal width to be set directly by an environment variable, or
+    when detecting that we're testing use a wide terminal to avoid line wrap issues.
+    """
+    width = kwargs.pop("width", None)
+    width_env = os.environ.get("TERMINAL_WIDTH")
+    pytest_version = os.environ.get("PYTEST_VERSION")
+    if width is not None:
+        pass
+    elif width_env is not None:
+        width = int(width_env)
+    elif pytest_version is not None:
+        width = TEST_TERMINAL_WIDTH
+    return Console(*args, width=width, **kwargs)

rich_objects-0.1.0/rich_objects/constants.py

@@ -0,0 +1,30 @@
+"""Internationalized constants for controlling appearance."""
+from gettext import gettext
+
+# allow for i18n/l8n
+ITEMS = gettext("Items")
+PROPERTY = gettext("Property")
+PROPERTIES = gettext("Properties")
+VALUE = gettext("Value")
+VALUES = gettext("Values")
+UNKNOWN = gettext("Unknown")
+FOUND_ITEMS = gettext("Found {} items")
+ELLIPSIS = gettext("...")
+
+OBJECT_HEADERS = [PROPERTY, VALUE]
+
+KEY_FIELDS = ["name", "id"]
+URL_PREFIXES = ["http://", "https://", "ftp://"]
+
+KEY_MAX_LEN = 35
+VALUE_MAX_LEN = 50
+URL_MAX_LEN = 100
+
+# this is value used to denote all other properties (not specified in list)
+WILDCARD_COLUMN = '*'
+
+DEFAULT_ROW_PROPS = {
+    "justify": "left",
+    "no_wrap": True,
+    "overflow": "ignore",
+}

rich_objects-0.1.0/rich_objects/display.py

@@ -0,0 +1,264 @@
+"""Implementation for displaying data in a user-friendly fashion."""
+from typing import Any
+from typing import Optional
+
+import yaml
+from rich.console import Console
+from rich.markup import escape
+
+from rich_objects.console import console_factory
+from rich_objects.constants import ELLIPSIS
+from rich_objects.constants import PROPERTIES
+from rich_objects.constants import WILDCARD_COLUMN
+from rich_objects.enums import OutputFormat
+from rich_objects.enums import OutputStyle
+from rich_objects.rich_table import RichTable
+from rich_objects.table_config import TableConfig
+
+# NOTE: the key field of dictionaries are expected to be be `str`, `int`, `float`, but use
+#       `Any` readability.
+
+
+def headerize(s: str) -> str:
+    """Create a table header from the provided string."""
+    if s == WILDCARD_COLUMN:
+        return PROPERTIES
+    return s[0].upper() + s[1:]
+
+
+def _truncate(s: str, max_length: int) -> str:
+    """Truncate the provided string to a maximum of max_length (including elipsis)."""
+    if len(s) < max_length:
+        return s
+    return s[: max_length - 3] + ELLIPSIS
+
+
+def _get_name_key(item: dict[Any, Any], key_fields: list[str]) -> Optional[str]:
+    """Attempt to find an identifying value."""
+    for k in key_fields:
+        key = str(k)
+        if key in item:
+            return key
+
+    return None
+
+
+def _get_other_key(item: dict[Any, Any], name_key: str) -> Optional[str]:
+    """Find the "other" key (if there's just one value)."""
+    keys = set(item.keys())
+    keys.remove(name_key)
+    if len(keys) != 1:
+        return None
+
+    return keys.pop()
+
+
+def _is_url(s: str, url_prefixes: list[str]) -> bool:
+    """Rudimentary check for somethingt starting with URL prefix."""
+    return any(s.startswith(p) for p in url_prefixes)
+
+
+def _safe(v: Any) -> str:
+    """Convert 'v' to a string that is properly escaped."""
+    return escape(str(v))
+
+
+def _create_list_table(
+    items: list[dict[Any, Any]], outer: bool, config: TableConfig
+) -> RichTable:
+    """Create a table from a list of dictionary items.
+
+    If an identifying "name key" is found (in the first entry), the table will have 2 columns: name, Properties
+    If no identifying "name key" is found, the table will be a single column table with the properties.
+
+    NOTE: nesting is done as needed
+    """
+    caption = config.items_caption.format(len(items)) if outer else None
+    name_key = _get_name_key(items[0], config.key_fields)
+    if not name_key:
+        # without identifiers just create table with one "Values" column
+        table = RichTable(
+            config.values_label,
+            outer=outer,
+            show_lines=True,
+            caption=caption,
+            row_props=config.row_properties,
+        )
+        for item in items:
+            table.add_row(_table_cell_value(item, config))
+        return table
+
+    # if there's just one property besides the key, use that as the label
+    name_label = headerize(name_key)
+    other_key = _get_other_key(items[0], name_key)
+    if other_key:
+        other_name = headerize(other_key)
+        fields = [name_label, other_name]
+        table = RichTable(
+            *fields,
+            outer=outer,
+            show_lines=True,
+            caption=caption,
+            row_props=config.row_properties,
+        )
+        for item in items:
+            # id may be an int, so convert to string before truncating
+            name = _safe(item.pop(name_key, config.unknown_label))
+            body = _table_cell_value(item.get(other_key), config)
+            table.add_row(_truncate(name, config.key_max_len), body)
+        return table
+
+    # create a table with identifier in left column, and rest of data in right column
+    fields = [name_label, config.properties_label]
+    table = RichTable(
+        *fields,
+        outer=outer,
+        show_lines=True,
+        caption=caption,
+        row_props=config.row_properties,
+    )
+    for item in items:
+        # id may be an int, so convert to string before truncating
+        name = _safe(item.pop(name_key, config.unknown_label))
+        body = _table_cell_value(item, config)
+        table.add_row(_truncate(name, config.key_max_len), body)
+
+    return table
+
+
+def _create_object_table(
+    obj: dict[Any, Any], outer: bool, config: TableConfig
+) -> RichTable:
+    """Create a table of a dictionary object.
+
+    NOTE: nesting is done in the right column as needed.
+    """
+    headers = [config.property_label, config.value_label]
+    table = RichTable(
+        *headers, outer=outer, show_lines=False, row_props=config.row_properties
+    )
+    for k, v in obj.items():
+        name = _safe(k)
+        table.add_row(_truncate(name, config.key_max_len), _table_cell_value(v, config))
+
+    return table
+
+
+def _table_cell_value(obj: Any, config: TableConfig) -> Any:
+    """Create the "inner" value for a table cell.
+
+    Depending on the input value type, the cell may look different. If a dict, or list[dict],
+    an inner table is created. Otherwise, the object is converted to a printable value.
+    """
+    value: Any = None
+    if isinstance(obj, dict):
+        value = _create_object_table(obj, outer=False, config=config)
+    elif isinstance(obj, list) and obj:
+        if isinstance(obj[0], dict):
+            value = _create_list_table(obj, outer=False, config=config)
+        else:
+            values = [str(x) for x in obj]
+            s = _safe(", ".join(values))
+            value = _truncate(s, config.value_max_len)
+    else:
+        s = _safe(obj)
+        max_len = (
+            config.url_max_len
+            if _is_url(s, config.url_prefixes)
+            else config.value_max_len
+        )
+        value = _truncate(s, max_len)
+
+    return value
+
+
+def _create_list_columns_table(items: list[dict[str, Any]], columns: list[str], config: TableConfig) -> RichTable:
+    """Create a table with the provided columns."""
+    headers = [headerize(c) for c in columns]
+    table = RichTable(
+        *headers, outer=True, show_lines=True, row_props=config.row_properties
+    )
+    for item in items:
+        values = []
+        for c in columns:
+            if c == WILDCARD_COLUMN:
+                sub_value = {k: v for k, v in item.items() if k not in columns}
+                values.append(_table_cell_value(sub_value, config))
+                continue
+            values.append(_table_cell_value(item.get(c), config))
+        table.add_row(*values)
+
+    return table
+
+
+def rich_table_factory(
+    obj: Any,
+    config: Optional[TableConfig] = None,
+    columns: Optional[list[str]] = None,
+) -> RichTable:
+    """Create a RichTable (alias for rich.table.Table) from the object."""
+    config = config or TableConfig()
+    if isinstance(obj, dict):
+        return _create_object_table(obj, outer=True, config=config)
+
+    if isinstance(obj, list) and obj and isinstance(obj[0], dict):
+        if columns:
+            return _create_list_columns_table(obj, columns=columns, config=config)
+
+        return _create_list_table(obj, outer=True, config=config)
+
+    # this is a list of "simple" properties
+    if (
+        isinstance(obj, list)
+        and obj
+        and all(
+            item is None or isinstance(item, (str, float, bool, int)) for item in obj
+        )
+    ):
+        caption = config.items_caption.format(len(obj))
+        table = RichTable(
+            config.items_label,
+            outer=True,
+            show_lines=True,
+            caption=caption,
+            row_props=config.row_properties,
+        )
+        for item in obj:
+            table.add_row(_table_cell_value(item, config))
+        return table
+
+    raise ValueError(f"Unable to create table for type {type(obj).__name__}")
+
+
+def display(
+    obj: Any,
+    fmt: OutputFormat,
+    style: OutputStyle,
+    indent: int = 2,
+    columns: Optional[list[str]] = None,
+    console: Optional[Console] = None,
+) -> None:
+    """Display the data provided in obj, according to the formating arguments."""
+    no_color = style != OutputStyle.ALL
+    highlight = style != OutputStyle.NONE
+    console = console or console_factory(no_color=no_color, highlight=highlight)
+
+    if isinstance(obj, str):
+        console.print(_safe(obj))
+        return
+
+    if fmt == OutputFormat.JSON:
+        console.print_json(data=obj, indent=indent, highlight=highlight)
+        return
+
+    if fmt == OutputFormat.YAML:
+        console.print(_safe(yaml.dump(obj, indent=indent)))
+        return
+
+    if not obj:
+        console.print("Nothing found")
+        return
+
+    table = rich_table_factory(obj, columns=columns)
+    console.print(table)
+    return

rich_objects-0.1.0/rich_objects/enums.py

@@ -0,0 +1,20 @@
+"""Simple enum definitions."""
+from enum import Enum
+
+
+class OutputFormat(str, Enum):
+    """Output text format for received data."""
+
+    TABLE = "table"
+    JSON = "json"
+    YAML = "yaml"
+
+
+class OutputStyle(str, Enum):
+    """Text style options for none, bold-only, or bold-and-color."""
+
+    NONE = "none"
+    BOLD = "bold"
+    ALL = "all"
+
+

rich_objects-0.1.0/rich_objects/rich_table.py

@@ -0,0 +1,40 @@
+"""Contains the RichTable class."""
+from typing import Any
+
+from rich.box import HEAVY_HEAD
+from rich.table import Table
+
+from rich_objects.constants import DEFAULT_ROW_PROPS
+
+
+class RichTable(Table):
+    """Wrapper for the rich.Table to provide some methods for adding complex items."""
+
+    def __init__(
+        self,
+        *args: Any,
+        outer: bool = True,
+        row_props: dict[str, Any] = DEFAULT_ROW_PROPS,
+        **kwargs: Any,
+    ):
+        """Initialize the Table with a few defaults."""
+        super().__init__(
+            # items with "regular" defaults
+            highlight=kwargs.pop("highlight", True),
+            row_styles=kwargs.pop("row_styles", None),
+            expand=kwargs.pop("expand", False),
+            caption_justify=kwargs.pop("caption_justify", "left"),
+            border_style=kwargs.pop("border_style", None),
+            leading=kwargs.pop(
+                "leading", 0
+            ),  # warning: setting to non-zero disables lines
+            # these items take queues from `outer`
+            show_header=kwargs.pop("show_header", outer),
+            show_edge=kwargs.pop("show_edge", outer),
+            box=HEAVY_HEAD if outer else None,
+            **kwargs,
+        )
+        for name in args:
+            self.add_column(name, **row_props)
+
+

rich_objects-0.1.0/rich_objects/table_config.py

@@ -0,0 +1,40 @@
+"""Contains TableConfig class which controlls the table outputs."""
+from dataclasses import dataclass
+from dataclasses import field
+from typing import Any
+
+from rich_objects.constants import DEFAULT_ROW_PROPS
+from rich_objects.constants import FOUND_ITEMS
+from rich_objects.constants import ITEMS
+from rich_objects.constants import KEY_FIELDS
+from rich_objects.constants import KEY_MAX_LEN
+from rich_objects.constants import PROPERTIES
+from rich_objects.constants import PROPERTY
+from rich_objects.constants import UNKNOWN
+from rich_objects.constants import URL_MAX_LEN
+from rich_objects.constants import URL_PREFIXES
+from rich_objects.constants import VALUE
+from rich_objects.constants import VALUE_MAX_LEN
+from rich_objects.constants import VALUES
+
+
+@dataclass
+class TableConfig:
+    """Configuration for customizing the table outputs.
+
+    The defaults provide a standard look and feel, but can be overridden to all customization.
+    """
+
+    items_label: str = ITEMS
+    property_label: str = PROPERTY
+    properties_label: str = PROPERTIES
+    value_label: str = VALUE
+    values_label: str = VALUES
+    unknown_label: str = UNKNOWN
+    items_caption: str = FOUND_ITEMS
+    url_prefixes: list[str] = field(default_factory=lambda: URL_PREFIXES)
+    url_max_len: int = URL_MAX_LEN
+    key_fields: list[str] = field(default_factory=lambda: KEY_FIELDS)
+    key_max_len: int = KEY_MAX_LEN
+    value_max_len: int = VALUE_MAX_LEN
+    row_properties: dict[str, Any] = field(default_factory=lambda: DEFAULT_ROW_PROPS)