ttkbootstrap 2.1.1__tar.gz → 2.2.0__tar.gz

{ttkbootstrap-2.1.1/src/ttkbootstrap.egg-info → ttkbootstrap-2.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ttkbootstrap
-Version: 2.1.1
+Version: 2.2.0
 Summary: A supercharged theme extension for tkinter that enables on-demand modern flat style themes inspired by Bootstrap.
 Author-email: Israel Dryer <israel.dryer@gmail.com>
 License-Expression: MIT AND (Apache-2.0 OR BSD-2-Clause)
@@ -66,6 +66,12 @@ tkinter's, and everything you already know about tkinter still applies.
 python -m pip install ttkbootstrap
 ```
 
+Then see it running — this opens a window with every widget and a theme picker:
+
+```bash
+ttkb demo
+```
+
 ## Quickstart
 
 ```python
@@ -115,6 +121,26 @@ app.toggle_theme()                # flip light <-> dark
 Browse them in the
 [themes gallery](https://ttkbootstrap.readthedocs.io/en/latest/themes.html).
 
+Design your own with the bundled editor — pick colors, preview them on live
+widgets, and export a `Theme(...)` snippet for your app:
+
+```bash
+ttkb creator
+```
+
+## Command line
+
+Installing ttkbootstrap installs `ttkb`:
+
+| Command | What it does |
+| --- | --- |
+| `ttkb version` | Print the installed version |
+| `ttkb demo` | Open the widget demo |
+| `ttkb convert-theme <file>` | Convert a 1.x theme file to the 2.x `Theme(...)` form |
+| `ttkb creator` | Open ttkcreator, the theme designer |
+
+See the [command-line reference](https://ttkbootstrap.readthedocs.io/en/latest/reference/cli.html).
+
 ## Documentation
 
 - **[Documentation](https://ttkbootstrap.readthedocs.io/en/latest/)** — guides, the widget catalog, and the API reference.
@@ -131,6 +157,13 @@ deprecation warning. The
 [Migrating to 2.0](https://ttkbootstrap.readthedocs.io/en/latest/user-guide/getting-started/migrating.html)
 guide sorts every change into breaking / deprecated / notable / new.
 
+Custom themes moved out of the package and into your own code. To bring one
+forward, convert the file 1.x saved:
+
+```bash
+ttkb convert-theme user.py -o brand.py
+```
+
 ## Icons
 
 ttkbootstrap ships with the full [Bootstrap Icons](https://icons.getbootstrap.com/)
@@ -142,8 +175,8 @@ ttk.Button(app, text="Settings", icon="gear-fill", bootstyle="primary")
 ```
 
 Need other icon families — Font Awesome, Material, Lucide, and more? The
-[ttkbootstrap-icons](https://github.com/israel-dryer/ttkbootstrap-icons) extension
-is still available and adds installable icon providers alongside the built-in set.
+[tkinter-icons](https://github.com/israel-dryer/tkinter-icons) extension adds
+sixteen icon sets (61,000+ icons) alongside the built-in set.
 
 ## Contributing
 

{ttkbootstrap-2.1.1 → ttkbootstrap-2.2.0}/README.md

@@ -39,6 +39,12 @@ tkinter's, and everything you already know about tkinter still applies.
 python -m pip install ttkbootstrap
 ```
 
+Then see it running — this opens a window with every widget and a theme picker:
+
+```bash
+ttkb demo
+```
+
 ## Quickstart
 
 ```python
@@ -88,6 +94,26 @@ app.toggle_theme()                # flip light <-> dark
 Browse them in the
 [themes gallery](https://ttkbootstrap.readthedocs.io/en/latest/themes.html).
 
+Design your own with the bundled editor — pick colors, preview them on live
+widgets, and export a `Theme(...)` snippet for your app:
+
+```bash
+ttkb creator
+```
+
+## Command line
+
+Installing ttkbootstrap installs `ttkb`:
+
+| Command | What it does |
+| --- | --- |
+| `ttkb version` | Print the installed version |
+| `ttkb demo` | Open the widget demo |
+| `ttkb convert-theme <file>` | Convert a 1.x theme file to the 2.x `Theme(...)` form |
+| `ttkb creator` | Open ttkcreator, the theme designer |
+
+See the [command-line reference](https://ttkbootstrap.readthedocs.io/en/latest/reference/cli.html).
+
 ## Documentation
 
 - **[Documentation](https://ttkbootstrap.readthedocs.io/en/latest/)** — guides, the widget catalog, and the API reference.
@@ -104,6 +130,13 @@ deprecation warning. The
 [Migrating to 2.0](https://ttkbootstrap.readthedocs.io/en/latest/user-guide/getting-started/migrating.html)
 guide sorts every change into breaking / deprecated / notable / new.
 
+Custom themes moved out of the package and into your own code. To bring one
+forward, convert the file 1.x saved:
+
+```bash
+ttkb convert-theme user.py -o brand.py
+```
+
 ## Icons
 
 ttkbootstrap ships with the full [Bootstrap Icons](https://icons.getbootstrap.com/)
@@ -115,8 +148,8 @@ ttk.Button(app, text="Settings", icon="gear-fill", bootstyle="primary")
 ```
 
 Need other icon families — Font Awesome, Material, Lucide, and more? The
-[ttkbootstrap-icons](https://github.com/israel-dryer/ttkbootstrap-icons) extension
-is still available and adds installable icon providers alongside the built-in set.
+[tkinter-icons](https://github.com/israel-dryer/tkinter-icons) extension adds
+sixteen icon sets (61,000+ icons) alongside the built-in set.
 
 ## Contributing
 

{ttkbootstrap-2.1.1 → ttkbootstrap-2.2.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "ttkbootstrap"
-version = "2.1.1"
+version = "2.2.0"
 description = "A supercharged theme extension for tkinter that enables on-demand modern flat style themes inspired by Bootstrap."
 readme = "README.md"
 requires-python = ">=3.10"
@@ -49,6 +49,13 @@ dependencies = ["pillow>=10,<13"]
 Homepage = "https://github.com/israel-dryer/ttkbootstrap"
 Documentation = "https://ttkbootstrap.readthedocs.io/en/latest/"
 
+[project.scripts]
+# Two names for one command: `ttkbootstrap` is guessable from the package name,
+# `ttkb` is what anyone types twice. When the scripts directory is not on PATH,
+# `python -m ttkbootstrap.cli <command>` runs the same thing.
+ttkbootstrap = "ttkbootstrap.cli:main"
+ttkb = "ttkbootstrap.cli:main"
+
 [tool.setuptools.packages.find]
 where = ["src"]
 

{ttkbootstrap-2.1.1 → ttkbootstrap-2.2.0}/src/ttkbootstrap/__init__.py

@@ -37,6 +37,11 @@ bootstyle)`.
 
 For more information, see: https://ttkbootstrap.readthedocs.io/
 """
+from importlib.metadata import (
+    PackageNotFoundError as _PackageNotFoundError,
+    version as _distribution_version,
+)
+
 from tkinter import (
     Menu as _tkMenu, Text as _tkText, Canvas as _tkCanvas, Tk as _tkTk,
     Frame as _tkFrame, Label as _tkLabel,
@@ -100,6 +105,20 @@ from ttkbootstrap.utils import (
     set_global_family,
 )
 
+try:
+    #: The installed distribution's version, e.g. `"2.2.0"`.
+    #
+    # Read from the installed metadata rather than written here, so
+    # `pyproject.toml` stays the one place the version literal lives. The
+    # consequence is that this reports what was *installed*: an editable install
+    # keeps whatever metadata it was built with until it is reinstalled.
+    __version__ = _distribution_version("ttkbootstrap")
+except _PackageNotFoundError:
+    # Running from a source tree that was never installed (e.g. PYTHONPATH=src)
+    # -- there is no metadata to read, and guessing one would be worse than
+    # saying so.
+    __version__ = "unknown"
+
 
 # --------------------------------------------------------------------------- #
 # Concrete ttk widget classes — the blessed `bootstyle` set.

{ttkbootstrap-2.1.1 → ttkbootstrap-2.2.0}/src/ttkbootstrap/__init__.pyi

@@ -21,6 +21,10 @@ from typing import Any, Callable
 
 from ttkbootstrap.style import AutoStyleMixin as AutoStyleMixin, BootMixin as BootMixin
 
+# Assigned in `__init__.py` rather than imported, so `_reexports` -- which
+# sources every name from an import statement -- cannot reach it.
+__version__: str
+
 from tkinter import Canvas as _tkinterCanvas
 from tkinter import Frame as _tkinterFrame
 from tkinter import Label as _tkinterLabel

{ttkbootstrap-2.1.1 → ttkbootstrap-2.2.0}/src/ttkbootstrap/__main__.py

@@ -139,7 +139,8 @@ def setup_demo(app: ttk.App, theme: str):
     return bag, gc
 
 
-if __name__ == "__main__":
+def main():
+    """Open the widget demo. Also what `ttkb demo` runs."""
     app = ttk.App("ttkbootstrap widget demo", minsize=(600, 0))
     # Hide it before building the UI, not after: a window is placed by its
     # window manager, and once it has been mapped, re-showing it is a fresh
@@ -159,3 +160,8 @@ if __name__ == "__main__":
     app.deiconify()
 
     app.mainloop()
+    return 0
+
+
+if __name__ == "__main__":
+    main()

ttkbootstrap-2.2.0/src/ttkbootstrap/cli.py

@@ -0,0 +1,124 @@
+"""The `ttkb` command line.
+
+One entry point for the things ttkbootstrap ships that are not library calls:
+the version, the widget demo, the 1.x theme converter, and ttkcreator. Each was
+reachable before only as its own `python -m ...` invocation, which nothing
+surfaced.
+
+The command installs under two names -- `ttkb` and `ttkbootstrap` -- that run
+the same thing, and `python -m ttkbootstrap.cli <command>` runs it too, which is
+what to reach for when the scripts directory is not on PATH::
+
+    ttkb version
+    ttkb demo
+    ttkb convert-theme user.py -o brand.py
+    ttkb creator
+"""
+import argparse
+import sys
+
+from ttkbootstrap import __version__
+
+
+def _run_version(args, parser):
+    """Print the installed version."""
+    print(__version__)
+    return 0
+
+
+def _run_demo(args, parser):
+    """Open the widget demo."""
+    from ttkbootstrap.__main__ import main
+
+    return main()
+
+
+def _run_creator(args, parser):
+    """Open ttkcreator."""
+    try:
+        from ttkcreator.__main__ import main
+    except ModuleNotFoundError as error:
+        # ttkcreator ships alongside ttkbootstrap but is a separate top-level
+        # package, so it can be absent from a trimmed install. Only report that
+        # when ttkcreator itself is what is missing -- an import failing *inside*
+        # it is a different problem, and saying "not installed" would send the
+        # user after a package they already have.
+        if error.name not in ("ttkcreator", "ttkcreator.__main__"):
+            raise
+        parser.exit(2, f"{parser.prog}: ttkcreator is not installed ({error}).\n")
+    return main()
+
+
+def _run_convert_theme(args, parser):
+    """Convert a 1.x theme file."""
+    from ttkbootstrap import convert_theme
+
+    return convert_theme.run(args, parser)
+
+
+def build_parser():
+    """Return the `ttkb` argument parser."""
+    parser = argparse.ArgumentParser(
+        prog="ttkb",
+        description="Command-line utilities for ttkbootstrap.",
+    )
+    parser.add_argument(
+        "-V", "--version", action="version", version=__version__
+    )
+    commands = parser.add_subparsers(dest="command", metavar="<command>")
+
+    version = commands.add_parser(
+        "version",
+        help="print the installed ttkbootstrap version",
+        description="Print the installed ttkbootstrap version.",
+    )
+    version.set_defaults(func=_run_version, parser=version)
+
+    demo = commands.add_parser(
+        "demo",
+        help="open the widget demo",
+        description="Open the widget demo -- every themed widget on one "
+                    "window, with a theme picker.",
+    )
+    demo.set_defaults(func=_run_demo, parser=demo)
+
+    # Imported lazily elsewhere, but the description and arguments are shared
+    # here so the two spellings of the converter cannot drift apart.
+    from ttkbootstrap import convert_theme
+
+    convert = commands.add_parser(
+        "convert-theme",
+        help="convert a 1.x theme file to the 2.x Theme(...) form",
+        description=convert_theme.DESCRIPTION,
+    )
+    convert_theme.add_arguments(convert)
+    convert.set_defaults(func=_run_convert_theme, parser=convert)
+
+    creator = commands.add_parser(
+        "creator",
+        help="open ttkcreator, the theme designer",
+        description="Open ttkcreator: edit a theme's colors, preview the "
+                    "result live, and export a Theme(...).register() snippet.",
+    )
+    creator.set_defaults(func=_run_creator, parser=creator)
+
+    return parser
+
+
+def main(argv=None):
+    """Run the `ttkb` command line."""
+    parser = build_parser()
+    args = parser.parse_args(argv)
+    if getattr(args, "func", None) is None:
+        # No subcommand. argparse can require one, but the error it prints on
+        # its own names the missing argument rather than showing what is
+        # available -- and a bare `ttkb` is someone asking exactly that.
+        parser.print_help()
+        return 2
+    # Each subparser records itself, so a failing command names itself in its
+    # usage line rather than the bare `ttkb`.
+    return args.func(args, args.parser)
+
+
+if __name__ == "__main__":
+    sys.exit(main())

ttkbootstrap-2.2.0/src/ttkbootstrap/convert_theme.py

@@ -0,0 +1,323 @@
+"""Convert a ttkbootstrap 1.x theme file into a 2.x ``Theme(...).register()`` snippet.
+
+Run it on a theme file saved by 1.x -- a ``user.py`` holding a ``USER_THEMES``
+dict, a ``.py`` holding the ``ThemeDefinition(...)`` call ttkcreator's *Export
+theme definition* wrote, or a JSON file in the ``Style.load_user_themes``
+format -- and it prints Python you paste into your own app::
+
+    ttkb convert-theme mythemes.json
+    ttkb convert-theme user.py -o brand.py
+
+The module stays runnable as ``python -m ttkbootstrap.convert_theme``, which is
+what to use when the scripts directory is not on PATH.
+
+The five accent anchors, the optional secondary accent, and the theme's
+background/foreground carry over. `border`, `inputbg`, `inputfg`, `selectbg`,
+`selectfg`, and `active` are dropped: 2.x derives them from the anchors. The
+`light` and `dark` accents are dropped too: 2.x derives that pair from the
+`neutral` ramp, which you set with `Theme(neutral=...)`. A 1.x theme declares
+one mode, so the generated family declares that mode and leaves the opposite
+one commented out.
+"""
+import argparse
+import ast
+import json
+import sys
+import textwrap
+from pathlib import Path
+
+#: 1.x color keys that carry over to a `Theme` anchor of the same name.
+_ACCENT_KEYS = ("primary", "success", "info", "warning", "danger")
+
+#: 1.x color keys the 2.x engine derives rather than reads.
+_DERIVED_KEYS = ("border", "inputbg", "inputfg", "selectbg", "selectfg", "active")
+
+#: 1.x accent keys 2.x derives from the `neutral` ramp instead.
+_NEUTRAL_KEYS = ("light", "dark")
+
+
+def _literal(value):
+    """Render a value as a Python string literal, escaping what it contains.
+
+    JSON string escapes are a subset of Python's, so `json.dumps` gives a
+    double-quoted literal that survives a quote or a backslash in a theme name
+    or a color -- the generated file is source we tell people to run.
+    """
+    return json.dumps(str(value))
+
+
+def load_legacy_themes(path):
+    """Read a 1.x theme file and return its ``{name: spec}`` mapping.
+
+    Parameters:
+
+        path (str or Path):
+            A ``.json`` file in the ``Style.load_user_themes`` format, or a
+            ``.py`` file defining a ``USER_THEMES`` dict or a
+            ``ThemeDefinition(...)`` call.
+
+    Returns:
+
+        dict:
+            Each 1.x spec, keyed by theme name.
+    """
+    path = Path(path)
+    text = path.read_text(encoding="utf-8")
+    if path.suffix == ".py":
+        themes = _themes_from_python(text, path)
+    else:
+        themes = _themes_from_json(text, path)
+    if not themes:
+        raise ValueError(f"{path}: no themes found.")
+    return themes
+
+
+def _themes_from_json(text, path):
+    """Return ``{name: spec}`` from a ``load_user_themes``-format JSON file."""
+    data = json.loads(text)
+    entries = data.get("themes", data) if isinstance(data, dict) else data
+    if isinstance(entries, dict):
+        return dict(entries)
+    if not isinstance(entries, list):
+        raise ValueError(
+            f"{path}: expected a theme mapping or a list of them, got "
+            f"{type(entries).__name__}."
+        )
+    themes = {}
+    for entry in entries:
+        if not isinstance(entry, dict):
+            raise ValueError(
+                f"{path}: expected each entry to be a theme mapping, got "
+                f"{type(entry).__name__}."
+            )
+        themes.update(entry)
+    return themes
+
+
+def _themes_from_python(text, path):
+    """Return ``{name: spec}`` from a 1.x ``user.py`` store or a ttkcreator
+    ``ThemeDefinition`` export."""
+    tree = ast.parse(text, filename=str(path))
+    themes = {}
+    for node in tree.body:
+        if not isinstance(node, ast.Assign):
+            continue
+        names = [t.id for t in node.targets if isinstance(t, ast.Name)]
+        if "USER_THEMES" in names or "STANDARD_THEMES" in names:
+            store = ast.literal_eval(node.value)
+            if not isinstance(store, dict):
+                raise ValueError(
+                    f"{path}: expected USER_THEMES to be a mapping of themes, "
+                    f"got {type(store).__name__}."
+                )
+            return dict(store)
+        call = _theme_definition_call(node.value)
+        if call is not None:
+            themes.update(_spec_from_definition(call, path))
+    if themes:
+        return themes
+    raise ValueError(
+        f"{path}: found neither a USER_THEMES assignment nor a "
+        "ThemeDefinition(...) call."
+    )
+
+
+def _theme_definition_call(node):
+    """Return the node when it is a ``ThemeDefinition(...)`` call, else None."""
+    if not isinstance(node, ast.Call):
+        return None
+    func = node.func
+    name = (
+        func.attr if isinstance(func, ast.Attribute)
+        else getattr(func, "id", None)
+    )
+    return node if name == "ThemeDefinition" else None
+
+
+def _spec_from_definition(call, path):
+    """Return ``{name: spec}`` from ttkcreator's *Export theme definition* file.
+
+    That export writes ``ThemeDefinition(name=..., themetype=...,
+    colors={...})``. 1.x took those three positionally as ``(name, colors,
+    themetype)``, with `themetype` defaulting to light, so both spellings are
+    read.
+    """
+    args = dict(zip(("name", "colors", "themetype"), call.args))
+    args.update({kw.arg: kw.value for kw in call.keywords if kw.arg})
+    try:
+        name = ast.literal_eval(args["name"])
+        colors = ast.literal_eval(args["colors"])
+    except KeyError as error:
+        raise ValueError(
+            f"{path}: ThemeDefinition(...) is missing {error.args[0]}."
+        ) from None
+    mode = "light"
+    if "themetype" in args:
+        mode = ast.literal_eval(args["themetype"])
+    return {name: {"type": mode, "colors": colors}}
+
+
+def _mode(name, spec):
+    """Return the theme's ``light``/``dark`` mode."""
+    if not isinstance(spec, dict):
+        raise ValueError(
+            f"theme {name!r}: expected a spec mapping, got "
+            f"{type(spec).__name__}."
+        )
+    mode = spec.get("mode") or spec.get("type")
+    if mode not in ("light", "dark"):
+        raise ValueError(
+            f"theme {name!r}: expected a 'mode' (or 1.x 'type') of 'light' or "
+            f"'dark', got {mode!r}."
+        )
+    return mode
+
+
+def _colors(name, spec):
+    """Return the theme's color mapping, checking the keys conversion needs."""
+    colors = spec.get("colors")
+    if not isinstance(colors, dict):
+        raise ValueError(f"theme {name!r}: missing a 'colors' mapping.")
+    missing = [k for k in _ACCENT_KEYS + ("bg", "fg") if not colors.get(k)]
+    if missing:
+        raise ValueError(
+            f"theme {name!r}: missing color(s) {', '.join(missing)}."
+        )
+    return colors
+
+
+def theme_snippet(name, spec):
+    """Render one 1.x theme spec as a ``ttk.Theme(...).register()`` call.
+
+    Parameters:
+
+        name (str):
+            The theme name; becomes the family name, so the call registers
+            ``<name>-light`` or ``<name>-dark``.
+
+        spec (dict):
+            A 1.x spec — ``{'type': 'light'|'dark', 'colors': {...}}``.
+
+    Returns:
+
+        str:
+            The rendered call, without a trailing newline.
+    """
+    mode = _mode(name, spec)
+    colors = _colors(name, spec)
+    other = "dark" if mode == "light" else "light"
+
+    primary = f"primary={_literal(colors['primary'])}"
+    if colors.get("secondary"):
+        primary += f", secondary={_literal(colors['secondary'])}"
+    lines = [
+        "ttk.Theme(",
+        f"    name={_literal(name)},",
+        f"    {primary},",
+        f"    success={_literal(colors['success'])}, "
+        f"info={_literal(colors['info'])},",
+        f"    warning={_literal(colors['warning'])}, "
+        f"danger={_literal(colors['danger'])},",
+        f"    {mode}=dict(background={_literal(colors['bg'])}, "
+        f"foreground={_literal(colors['fg'])}),",
+        f"    # {other}=dict(background=..., foreground=...),"
+        f"  # 1.x theme was {mode}-only",
+        ").register()",
+    ]
+    return "\n".join(lines)
+
+
+def convert(path):
+    """Convert a 1.x theme file into a runnable Python module.
+
+    Parameters:
+
+        path (str or Path):
+            The 1.x ``.json`` or ``.py`` theme file.
+
+    Returns:
+
+        str:
+            Python source registering every theme in the file.
+    """
+    themes = load_legacy_themes(path)
+    dropped = ", ".join(_DERIVED_KEYS[:-1]) + f", and {_DERIVED_KEYS[-1]}"
+    note = textwrap.wrap(
+        f"The 1.x {dropped} values are dropped; 2.x derives them from the "
+        f"anchors below. So are the {' and '.join(_NEUTRAL_KEYS)} accents; 2.x "
+        f"derives that pair from the neutral ramp, which Theme(neutral=...) "
+        f"sets.",
+        width=75,
+    )
+    # A registered theme is selectable by name, and the name is `<family>-<mode>`
+    # rather than the 1.x name -- so show it. Naming the first theme names the
+    # one they just converted.
+    first, first_spec = next(iter(themes.items()))
+    registered = f"{first}-{_mode(first, first_spec)}"
+    header = [
+        f"# Converted from {Path(path).name} by ttkb convert-theme.",
+        "#",
+        *(f"# {line}" for line in note),
+        "#",
+        "# Import this module, then select the theme by name:",
+        f"#     app = ttk.App(theme={_literal(registered)})",
+        "",
+        "import ttkbootstrap as ttk",
+        "",
+        "",
+    ]
+    blocks = [theme_snippet(name, spec) for name, spec in themes.items()]
+    return "\n".join(header) + "\n\n".join(blocks) + "\n"
+
+
+#: One-line summary, shared by this module's parser and the `ttkb` subcommand.
+DESCRIPTION = (
+    "Convert a ttkbootstrap 1.x theme file into a 2.x Theme(...).register() "
+    "snippet."
+)
+
+
+def add_arguments(parser):
+    """Add the converter's arguments to `parser`.
+
+    Shared with the `ttkb convert-theme` subcommand so the two spellings cannot
+    drift apart.
+    """
+    parser.add_argument(
+        "file",
+        help="a 1.x theme file (.json, or a .py USER_THEMES / ThemeDefinition "
+             "store)",
+    )
+    parser.add_argument(
+        "-o", "--output", help="write to this file instead of standard output"
+    )
+    return parser
+
+
+def run(args, parser):
+    """Convert the file named by `args`, reporting failures through `parser`."""
+    try:
+        source = convert(args.file)
+        if args.output:
+            Path(args.output).write_text(source, encoding="utf-8")
+    except (OSError, ValueError, SyntaxError) as error:
+        parser.exit(2, f"{parser.prog}: {error}\n")
+
+    if args.output:
+        print(f"Wrote {args.output}", file=sys.stderr)
+    else:
+        sys.stdout.write(source)
+    return 0
+
+
+def main(argv=None):
+    """Run the command-line converter."""
+    parser = argparse.ArgumentParser(
+        prog="python -m ttkbootstrap.convert_theme", description=DESCRIPTION
+    )
+    add_arguments(parser)
+    return run(parser.parse_args(argv), parser)
+
+
+if __name__ == "__main__":
+    sys.exit(main())

{ttkbootstrap-2.1.1 → ttkbootstrap-2.2.0}/src/ttkbootstrap/style/engine.py

@@ -951,7 +951,19 @@ class Style(ttk.Style):
         self.register_theme(theme)
 
     def load_user_themes(self, file):
-        """Load user themes saved in json format"""
+        """Register themes from a 1.x JSON theme file.
+
+        The file holds ``{"themes": [{"<name>": {"type": "light"|"dark",
+        "colors": {...}}}]}`` with the sixteen 1.x color keys, taken verbatim.
+        Each theme registers under its own name as a single mode. To convert a
+        1.x theme into a light/dark `Theme` family whose plumbing colors are
+        regenerated, run ``ttkb convert-theme`` instead.
+
+        Parameters:
+
+            file (str):
+                Path to the JSON theme file.
+        """
         with open(file, encoding='utf-8') as f:
             data = json.load(f)
             themes = data['themes']