plesty-sdk 0.0.2.dev6__tar.gz → 0.0.2.dev10__tar.gz

{plesty_sdk-0.0.2.dev6 → plesty_sdk-0.0.2.dev10}/.gitignore

@@ -7,3 +7,6 @@ uv.lock
 build/
 dist/
 *.egg-info/
+
+logs/
+*.log

{plesty_sdk-0.0.2.dev6 → plesty_sdk-0.0.2.dev10}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: plesty-sdk
-Version: 0.0.2.dev6
+Version: 0.0.2.dev10
 Summary: Command-line application for developing Python modules compliant with the Plesty standard.
 Author: Plesty Development Team
 License-File: COPYING
@@ -9,6 +9,7 @@ License-File: LICENSE
 Requires-Python: >=3.12
 Requires-Dist: click>=3.8
 Requires-Dist: livereload>=2.7.1
+Requires-Dist: md2pdf>=3.1.1
 Requires-Dist: myst-parser>=5.0.0
 Requires-Dist: pydata-sphinx-theme==0.17.1
 Requires-Dist: ruff>=0.14
@@ -19,6 +20,8 @@ Requires-Dist: sphinx-external-toc>=1.1.0
 Requires-Dist: sphinx>=9.1.0
 Requires-Dist: sphinxcontrib-mermaid>=2.0.0
 Requires-Dist: watchfiles>=1.1.1
+Provides-Extra: pdf
+Requires-Dist: md2pdf>=3.1.1; extra == 'pdf'
 Description-Content-Type: text/markdown
 
 # plesty-sdk - Setting the Coding Standard

plesty_sdk-0.0.2.dev10/plesty_sdk/cli.py

@@ -0,0 +1,26 @@
+"""CLI tool for generating and updating license headers."""
+
+#
+# SPDX-FileCopyrightText: 2026 Plesty Development Team
+# SPDX-License-Identifier: LGPL-3.0-or-later
+# Author: Yunshuang Yuan
+# Email: yunshuang.yuan@fkp.uni-hannover.de
+#
+
+import click
+
+from .commands.build import build_command
+from .commands.check import check_command
+from .commands.docs import docs_command
+from .commands.license import license_command
+
+
+@click.group("plesty")
+def app():
+    """The Plesty CLI tool."""
+
+
+app.add_command(check_command)
+app.add_command(docs_command)
+app.add_command(license_command)
+app.add_command(build_command)

plesty_sdk-0.0.2.dev10/plesty_sdk/commands/__init__.py

@@ -0,0 +1 @@
+"""Plesty CLI command modules."""

plesty_sdk-0.0.2.dev10/plesty_sdk/commands/build.py

@@ -0,0 +1,243 @@
+"""CLI command for creating a new Plesty device project from template."""
+
+#
+# SPDX-FileCopyrightText: 2026 Plesty Development Team
+# SPDX-License-Identifier: LGPL-3.0-or-later
+# Author: Yunshuang Yuan
+# Email: yunshuang.yuan@fkp.uni-hannover.de
+#
+
+from __future__ import annotations
+
+import re
+import shutil
+import subprocess
+import tempfile
+from pathlib import Path
+
+import click
+
+
+DEVICE_TEMPLATE_REPO_URL = "https://gitlab.com/plesty/templates/plesty-demo-device.git"
+EXPERIMENT_TEMPLATE_REPO_URL = "https://gitlab.com/plesty/templates/plesty-demo-experiment.git"
+DEVICE_NAME_PATTERN = re.compile(r"^[a-z][a-z0-9_]*$")
+
+
+def _parse_device_name(device_name: str) -> tuple[str, str, str]:
+    """Validate device name and return naming variants."""
+    if not DEVICE_NAME_PATTERN.match(device_name):
+        raise click.ClickException(
+            "Invalid device name. Use lowercase letters, numbers, and '_' only "
+            "(for example: demo or power_meter)."
+        )
+
+    module_snake = device_name
+    module_title = " ".join(part.capitalize() for part in module_snake.split("_"))
+    module_pascal = "".join(part.capitalize() for part in module_snake.split("_"))
+    return module_snake, module_title, module_pascal
+
+
+def _clone_template(template_repo_url: str, destination: Path) -> None:
+    """Clone template repository to a destination folder."""
+    try:
+        subprocess.run(
+            ["git", "clone", "--depth", "1", template_repo_url, str(destination)],
+            check=True,
+            capture_output=True,
+            text=True,
+        )
+    except subprocess.CalledProcessError as exc:
+        raise click.ClickException(
+            f"Failed to clone template repository: {exc.stderr.strip() or exc.stdout.strip()}"
+        ) from exc
+
+
+def _rename_paths(root: Path, replacements: list[tuple[str, str]]) -> None:
+    """Rename files and directories if their names contain template tokens."""
+    all_paths = sorted(root.rglob("*"), key=lambda p: len(p.parts), reverse=True)
+    for path in all_paths:
+        name = path.name
+        new_name = name
+        for source, target in replacements:
+            new_name = new_name.replace(source, target)
+        if new_name != name:
+            path.rename(path.with_name(new_name))
+
+
+def _replace_text_tokens(root: Path, replacements: list[tuple[str, str]]) -> None:
+    """Replace template tokens inside text files."""
+    for path in root.rglob("*"):
+        if not path.is_file():
+            continue
+        try:
+            text = path.read_text(encoding="utf-8")
+        except (UnicodeDecodeError, OSError):
+            continue
+
+        new_text = text
+        for source, target in replacements:
+            new_text = new_text.replace(source, target)
+
+        if new_text != text:
+            path.write_text(new_text, encoding="utf-8")
+
+
+def _update_pyproject_author(pyproject_path: Path, author: str | None, email: str | None) -> None:
+    """Update author fields in pyproject.toml if values are provided."""
+    if author is None and email is None:
+        return
+
+    text = pyproject_path.read_text(encoding="utf-8")
+    pattern = re.compile(
+        r"authors\s*=\s*\[\s*\{\s*name\s*=\s*\"(?P<name>[^\"]*)\"\s*,\s*email\s*=\s*\"(?P<email>[^\"]*)\"\s*\}\s*\]",
+        flags=re.S,
+    )
+    matched = pattern.search(text)
+    if not matched:
+        raise click.ClickException("Could not find [project].authors entry in pyproject.toml.")
+
+    new_name = author if author is not None else matched.group("name")
+    new_email = email if email is not None else matched.group("email")
+
+    replacement = (
+        "authors = [\n"
+        f"  {{ name = \"{new_name}\", email = \"{new_email}\" }}\n"
+        "]"
+    )
+    updated = pattern.sub(replacement, text, count=1)
+    pyproject_path.write_text(updated, encoding="utf-8")
+
+
+def _scaffold_from_template(
+    *,
+    template_repo_url: str,
+    project_name: str,
+    module_name: str,
+    outpath: Path,
+    path_replacements: list[tuple[str, str]],
+    content_replacements: list[tuple[str, str]],
+    author: str | None,
+    email: str | None,
+) -> Path:
+    """Create a project from template with path/content/token replacements."""
+    output_dir = outpath.resolve()
+    output_dir.mkdir(parents=True, exist_ok=True)
+    target_dir = output_dir / project_name
+
+    if target_dir.exists():
+        raise click.ClickException(f"Target path already exists: {target_dir}")
+
+    with tempfile.TemporaryDirectory(prefix="plesty-build-") as tmp_dir:
+        template_dir = Path(tmp_dir) / "template"
+        _clone_template(template_repo_url, template_dir)
+
+        # Keep generated project clean from template git history.
+        shutil.rmtree(template_dir / ".git", ignore_errors=True)
+
+        shutil.copytree(template_dir, target_dir)
+
+    _rename_paths(target_dir, path_replacements)
+    _replace_text_tokens(target_dir, content_replacements)
+    _update_pyproject_author(target_dir / "pyproject.toml", author=author, email=email)
+
+    click.echo(f"Initialized project at: {target_dir}")
+    click.echo(f"Python module name: {module_name}")
+    return target_dir
+
+
+@click.group(name="build", short_help="Scaffold new Plesty projects from templates.")
+def build_command() -> None:
+    """Build projects from predefined Plesty templates."""
+
+
+@build_command.command(name="device", short_help="Initialize a new Plesty device project.")
+@click.option("--name", "device_name", required=True, help="Device/module name (for example: power_meter).")
+@click.option(
+    "--outpath",
+    type=click.Path(file_okay=False, dir_okay=True, path_type=Path),
+    default=Path("."),
+    show_default=True,
+    help="Output directory where the generated project folder will be created.",
+)
+@click.option("--author", default=None, help="Author name for pyproject.toml.")
+@click.option("--email", default=None, help="Author email for pyproject.toml.")
+def build_device_command(
+    device_name: str,
+    outpath: Path,
+    author: str | None,
+    email: str | None,
+) -> None:
+    """Create a new project in format plesty-[device_name]-device."""
+    module_snake, module_title, module_pascal = _parse_device_name(device_name)
+    project_name = f"plesty-{module_snake}-device"
+
+    content_replacements = [
+        ("PlestyDemoDevice", f"Plesty{module_pascal}Device"),
+        ("plesty_demo_device", module_snake),
+        ("plesty-demo-device", project_name),
+        ("Plesty Demo Device", f"Plesty {module_title} Device"),
+    ]
+
+    path_replacements = [
+        ("plesty_demo_device", module_snake),
+        ("plesty-demo-device", project_name),
+    ]
+
+    _scaffold_from_template(
+        template_repo_url=DEVICE_TEMPLATE_REPO_URL,
+        project_name=project_name,
+        module_name=module_snake,
+        outpath=outpath,
+        path_replacements=path_replacements,
+        content_replacements=content_replacements,
+        author=author,
+        email=email,
+    )
+
+
+@build_command.command(name="experiment", short_help="Initialize a new Plesty experiment project.")
+@click.option("--name", "experiment_name", required=True, help="Experiment/module name (for example: imaging_scan).")
+@click.option(
+    "--outpath",
+    type=click.Path(file_okay=False, dir_okay=True, path_type=Path),
+    default=Path("."),
+    show_default=True,
+    help="Output directory where the generated project folder will be created.",
+)
+@click.option("--author", default=None, help="Author name for pyproject.toml.")
+@click.option("--email", default=None, help="Author email for pyproject.toml.")
+def build_experiment_command(
+    experiment_name: str,
+    outpath: Path,
+    author: str | None,
+    email: str | None,
+) -> None:
+    """Create a new project in format plesty-[experiment_name]-experiment."""
+    module_snake, module_title, _ = _parse_device_name(experiment_name)
+    project_name = f"plesty-{module_snake}-experiment"
+
+    content_replacements = [
+        ("plesty-demo-experiment", project_name),
+        ("Plesty Demo Experiment", f"Plesty {module_title} Experiment"),
+        # Some template fields currently use device tokens; normalize those too.
+        ("Plesty Demo Device", f"Plesty {module_title} Experiment"),
+        ("plesty_demo_device", module_snake),
+        ("demo", module_snake),
+    ]
+
+    path_replacements = [
+        ("plesty-demo-experiment", project_name),
+        ("plesty_demo_device", module_snake),
+        ("demo", module_snake),
+    ]
+
+    _scaffold_from_template(
+        template_repo_url=EXPERIMENT_TEMPLATE_REPO_URL,
+        project_name=project_name,
+        module_name=module_snake,
+        outpath=outpath,
+        path_replacements=path_replacements,
+        content_replacements=content_replacements,
+        author=author,
+        email=email,
+    )

{plesty_sdk-0.0.2.dev6 → plesty_sdk-0.0.2.dev10}/plesty_sdk/commands/docs/__init__.py

@@ -20,6 +20,7 @@
 import click
 
 from plesty_sdk.commands.docs.deploy import deploy_command
+from plesty_sdk.commands.docs.generate import generate_command
 from plesty_sdk.commands.docs.serve import serve_command
 from plesty_sdk.context import ApplicationContext, pass_context
 
@@ -32,4 +33,5 @@ def docs_command(context: ApplicationContext):
 
 
 docs_command.add_command(deploy_command)
+docs_command.add_command(generate_command)
 docs_command.add_command(serve_command)

plesty_sdk-0.0.2.dev10/plesty_sdk/commands/docs/generate.py

@@ -0,0 +1,259 @@
+
+"""Generate default device documentation files for external Plesty devices."""
+
+# Author: Yunshuang Yuan 
+# Email: yunshuang.yuan@fkp.uni-hannover.de
+
+from importlib import import_module
+from pathlib import Path
+import inspect
+import sys
+import tempfile
+
+import click
+
+from plesty_sdk.context import ApplicationContext, pass_context
+
+
+PDF_COMMON_CSS = """
+body {
+    font-family: "DejaVu Sans", "Noto Sans", sans-serif;
+    font-size: 10pt;
+    line-height: 1.35;
+}
+
+table {
+    width: 100%;
+    border-collapse: collapse;
+    table-layout: fixed;
+    font-size: 8.5pt;
+}
+
+th,
+td {
+    border: 1px solid #d0d7de;
+    padding: 4px 6px;
+    vertical-align: top;
+    overflow-wrap: anywhere;
+}
+
+pre,
+code {
+    white-space: pre-wrap;
+    overflow-wrap: anywhere;
+}
+"""
+
+
+def _pdf_page_css(style: str) -> str:
+    """Return page-level CSS tuned for each generated markdown style."""
+    if style == 'md':
+        # Wide table docs are easier to read in landscape with tighter margins.
+        page_css = "@page { size: A4 landscape; margin: 8mm; }"
+    else:
+        page_css = "@page { size: A4 portrait; margin: 12mm; }"
+
+    return f"{page_css}\n{PDF_COMMON_CSS}"
+
+
+def _replace_device_doc_label(file_path: Path, module_name: str) -> None:
+    """Replace generic device label in generated docs with module-specific text."""
+    text = file_path.read_text(encoding='utf-8')
+    text = text.replace("Device Doc", f"Device Doc: {module_name}")
+    file_path.write_text(text, encoding='utf-8')
+
+
+def _prepare_markdown_for_pdf(markdown_text: str, style: str) -> str:
+    """Normalize markdown so md2pdf renders parameter lists reliably."""
+    text = markdown_text.replace("\r\n", "\n")
+    if style == 'short':
+        # Ensure parameter bullets are parsed as list items in PDF renderer.
+        text = text.replace("Parameters:\n  - ", "Parameters:\n\n- ")
+        text = text.replace("\n  - ", "\n- ")
+    return text
+
+
+def _discover_modules_from_init(device_root: Path) -> list[str]:
+    """Discover importable package names from __init__.py files under a device root."""
+    modules: list[str] = []
+    for init_file in device_root.glob("**/__init__.py"):
+        rel = init_file.relative_to(device_root)
+        package_parts = rel.parts[:-1]
+        if not package_parts:
+            continue
+        module = ".".join(package_parts)
+        if module not in modules:
+            modules.append(module)
+    modules.sort(key=lambda x: (x.count('.'), x))
+    return modules
+
+
+@click.command(
+    name='generate',
+    short_help="Generate default docs files from an external device's DocDevice.",
+)
+@click.argument(
+    'device_root',
+    required=True,
+    type=click.Path(exists=True, file_okay=False, dir_okay=True, path_type=Path),
+)
+@click.option(
+    '--module-name',
+    default=None,
+    metavar='<MODULE>',
+    help=(
+        "Python module containing DocDevice. "
+        "Defaults to folder name with '-' replaced by '_' (e.g. ape_pulse_slicer)."
+    ),
+)
+@click.option(
+    '--output-dir',
+    default=None,
+    type=click.Path(path_type=Path),
+    metavar='<PATH>',
+    help="Directory for generated docs. Defaults to <device_root>/docs.",
+)
+@click.option(
+    '--with-pdf/--no-pdf',
+    default=False,
+    show_default=True,
+    help='Also generate PDF files from the generated Markdown files.',
+)
+@pass_context
+def generate_command(
+    context: ApplicationContext,
+    device_root: Path,
+    module_name: str | None,
+    output_dir: Path | None,
+    with_pdf: bool,
+):
+    """Generate short.md, table.md and googledoc.py for an external device package.
+
+    DEVICE_ROOT should point to a package root such as:
+    /PLESTY/ape-pulse-slicer
+    """
+    del context  # command does not require project context settings
+
+    device_root = device_root.resolve()
+    inferred_module_name = device_root.name.replace('-', '_')
+    module_name = module_name or inferred_module_name
+    output_path = output_dir.resolve() if output_dir is not None else device_root / 'docs'
+    output_path.mkdir(parents=True, exist_ok=True)
+
+    if module_name == inferred_module_name and not (device_root / module_name).exists():
+        click.secho(
+            (
+                "Warning: device structure does not match standard layout "
+                f"(<device_root>/{module_name} not found). "
+                "Falling back to inferred module import. "
+                "Use --module-name to override."
+            ),
+            fg='yellow',
+            err=True,
+        )
+
+    if str(device_root) not in sys.path:
+        sys.path.insert(0, str(device_root))
+
+    try:
+        module = import_module(module_name)
+    except Exception as exc:
+        click.secho(
+            (
+                f"Warning: Failed to import module '{module_name}' from '{device_root}': {exc}. "
+                "Trying fallback package discovery from __init__.py files."
+            ),
+            fg='yellow',
+            err=True,
+        )
+        module = None
+        for candidate in _discover_modules_from_init(device_root):
+            try:
+                module = import_module(candidate)
+                module_name = candidate
+                click.secho(
+                    f"Warning: Falling back to discovered module '{module_name}'.",
+                    fg='yellow',
+                    err=True,
+                )
+                break
+            except Exception:
+                continue
+        if module is None:
+            raise click.ClickException(
+                "Failed to import module for documentation generation. "
+                "Provide --module-name explicitly."
+            )
+
+    if hasattr(module, 'DocDevice'):
+        doc_device = getattr(module, 'DocDevice')
+    elif hasattr(module, 'Device'):
+        click.secho(
+            (
+                f"Warning: Module '{module_name}' does not expose 'DocDevice'. "
+                "Falling back to 'Device' for documentation generation."
+            ),
+            fg='yellow',
+            err=True,
+        )
+        doc_device = getattr(module, 'Device')
+    else:
+        raise click.ClickException(
+            f"Module '{module_name}' does not expose 'DocDevice' or 'Device'."
+        )
+
+    if inspect.isclass(doc_device):
+        try:
+            doc_device = doc_device()
+        except Exception as exc:
+            raise click.ClickException(
+                f"Failed to instantiate '{module_name}' documentation device: {exc}"
+            )
+
+    if not hasattr(doc_device, 'summary') or not callable(getattr(doc_device, 'summary')):
+        raise click.ClickException(
+            f"'{module_name}.DocDevice' must provide a callable 'summary' method."
+        )
+
+    targets = {
+        'short': output_path / 'short.md',
+        'md': output_path / 'table.md',
+    }
+
+    md2pdf_callable = None
+    if with_pdf:
+        try:
+            from md2pdf.core import md2pdf
+        except ImportError as exc:
+            raise click.ClickException(
+                "Python package 'md2pdf' is not installed in the current environment. "
+                "Install it first (for example: pip install md2pdf or pip install 'plesty-sdk[pdf]')."
+            ) from exc
+        md2pdf_callable = md2pdf
+
+    for style, file_path in targets.items():
+        doc_device.summary(style=style, filename=str(file_path))
+        _replace_device_doc_label(file_path, module_name)
+        click.echo(f"Generated {file_path}")
+
+        if with_pdf:
+            try:
+                pdf_path = file_path.with_suffix('.pdf')
+                markdown_text = file_path.read_text(encoding='utf-8')
+                markdown_text = _prepare_markdown_for_pdf(markdown_text, style)
+                with tempfile.TemporaryDirectory(prefix='plesty-md2pdf-') as tmp_dir:
+                    css_path = Path(tmp_dir) / f'{style}.css'
+                    css_path.write_text(_pdf_page_css(style), encoding='utf-8')
+                    md2pdf_callable(
+                        pdf=pdf_path,
+                        raw=markdown_text,
+                        css=css_path,
+                        base_url=file_path.parent,
+                        extras=['tables', 'fenced_code'],
+                    )
+            except Exception as exc:
+                raise click.ClickException(
+                    f"Failed to generate PDF for '{file_path.name}': {exc}"
+                )
+
+            click.echo(f"Generated {pdf_path}")

plesty_sdk-0.0.2.dev10/plesty_sdk/commands/license.py

@@ -0,0 +1,191 @@
+"""Commands for maintaining SPDX license headers in project sources."""
+
+# Copyright (C) 2025, 2026 Christopher Borchers, fvrehlinger, Maximilian
+# Heller, Michael Zopf (names in alphabetic order wrt. surnames)
+#
+# This file is part of plesty-sdk which is part of the Plesty library.
+#
+# plesty-sdk is free software: you can redistribute it and/or modify it under
+# the terms of the GNU Lesser General Public License as published by the Free
+# Software Foundation, either version 3 of the License, or (at your option) any
+# later version.
+#
+# plesty-sdk is distributed in the hope that it will be useful, but WITHOUT ANY
+# WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A
+# PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public License along
+# with plesty-sdk. If not, see <https://www.gnu.org/licenses/>.
+
+from __future__ import annotations
+
+import re
+import subprocess
+import sys
+import tomllib
+from pathlib import Path
+from typing import Any
+
+import click
+
+from plesty_sdk.context import ApplicationContext, pass_context
+
+
+@click.group("license")
+@pass_context
+def license_command(context: ApplicationContext):
+	"""Update and apply SPDX license headers in source files."""
+	del context
+
+
+@license_command.command(name="update", short_help="Update and apply SPDX headers.")
+@click.argument(
+	"project_root",
+	required=False,
+	default=Path("."),
+	type=click.Path(exists=True, file_okay=False, dir_okay=True, path_type=Path),
+)
+@pass_context
+def update_command(context: ApplicationContext, project_root: Path):
+	"""Update `spdx.tmpl` author metadata and apply license headers.
+
+	This command:
+	0. Uses `<PROJECT_ROOT>` (or current directory if omitted).
+	1. Reads the first author entry from `pyproject.toml`.
+	2. Reads the first maintainer entry from `pyproject.toml`.
+	3. Updates `Author:` and `Email:` entries in `spdx.tmpl`.
+	4. Runs `licenseheaders` over Python files in the project.
+	"""
+	root = project_root.resolve()
+	pyproject_toml = context.pyproject_toml if root == Path.cwd() else _read_pyproject_toml(root)
+	project_section = _get_project_section(pyproject_toml)
+	author_name, author_email = _get_author_identity(project_section)
+	maintainer_name = _get_maintainer_name(project_section)
+
+	template_path = root / "spdx.tmpl"
+	_update_spdx_template(template_path, author_name, author_email)
+
+	_run_licenseheaders(template_path, maintainer_name, root)
+	click.echo("License headers updated successfully.")
+
+
+def _read_pyproject_toml(project_root: Path) -> dict[str, Any]:
+	"""Read pyproject.toml from a given project root directory."""
+	pyproject_path = project_root / "pyproject.toml"
+	if not pyproject_path.is_file():
+		raise click.ClickException(
+			f"No pyproject.toml found in project root: {project_root}"
+		)
+
+	with open(pyproject_path, "rb") as file:
+		return tomllib.load(file)
+
+
+def _get_project_section(pyproject_toml: dict[str, Any]) -> dict[str, Any]:
+	"""Return the `[project]` section from pyproject content."""
+	try:
+		return pyproject_toml["project"]
+	except KeyError as exc:
+		raise click.ClickException("Missing [project] section in pyproject.toml.") from exc
+
+
+def _get_author_identity(project_section: dict[str, Any]) -> tuple[str, str]:
+	"""Read the first author name and email from `[project].authors`."""
+	authors = project_section.get("authors")
+	if not isinstance(authors, list) or len(authors) == 0:
+		raise click.ClickException(
+			"Missing or empty [project].authors in pyproject.toml. "
+			"Expected at least one author with name and email."
+		)
+
+	first_author = authors[0]
+	if not isinstance(first_author, dict):
+		raise click.ClickException("First [project].authors entry must be a table with name and email.")
+
+	name = first_author.get("name")
+	email = first_author.get("email")
+	if not isinstance(name, str) or not name.strip():
+		raise click.ClickException("First [project].authors entry must define a non-empty name.")
+	if not isinstance(email, str) or not email.strip():
+		raise click.ClickException("First [project].authors entry must define a non-empty email.")
+
+	return name.strip(), email.strip()
+
+
+def _get_maintainer_name(project_section: dict[str, Any]) -> str:
+	"""Read the first maintainer name from `[project].maintainers`."""
+	maintainers = project_section.get("maintainers")
+	if not isinstance(maintainers, list) or len(maintainers) == 0:
+		raise click.ClickException(
+			"Missing or empty [project].maintainers in pyproject.toml. "
+			"Expected at least one maintainer with a name."
+		)
+
+	first_maintainer = maintainers[0]
+	if not isinstance(first_maintainer, dict):
+		raise click.ClickException("First [project].maintainers entry must be a table with a name.")
+
+	name = first_maintainer.get("name")
+	if not isinstance(name, str) or not name.strip():
+		raise click.ClickException("First [project].maintainers entry must define a non-empty name.")
+
+	return name.strip()
+
+
+def _update_spdx_template(template_path: Path, author_name: str, author_email: str) -> None:
+	"""Replace `Author:` and `Email:` lines in the SPDX template file."""
+	if not template_path.is_file():
+		raise click.ClickException(
+			f"No spdx template found at {template_path}. "
+			"Create `spdx.tmpl` in the project root first."
+		)
+
+	content = template_path.read_text(encoding="utf-8")
+	updated = re.sub(r"^Author:\s*.*$", f"Author: {author_name}", content, flags=re.MULTILINE)
+	updated = re.sub(r"^Email:\s*.*$", f"Email: {author_email}", updated, flags=re.MULTILINE)
+
+	if "Author:" not in updated:
+		updated = updated.rstrip() + f"\nAuthor: {author_name}\n"
+	if "Email:" not in updated:
+		updated = updated.rstrip() + f"\nEmail: {author_email}\n"
+
+	template_path.write_text(updated, encoding="utf-8")
+	click.echo(f"Updated {template_path}")
+
+
+def _run_licenseheaders(template_path: Path, owner: str, project_root: Path) -> None:
+	"""Run the licenseheaders command with the default Plesty parameters."""
+	args = [
+		"-t",
+		str(template_path),
+		"-cy",
+		"-o",
+		owner,
+		"-E",
+		".py",
+		"-x",
+		".venv",
+		"build",
+		"dist",
+		".git",
+	]
+
+	commands = [
+		["licenseheaders", *args],
+		[sys.executable, "-m", "licenseheaders", *args],
+	]
+
+	errors: list[str] = []
+	for command in commands:
+		result = subprocess.run(command, capture_output=True, text=True, cwd=project_root)
+		if result.returncode == 0:
+			if result.stdout.strip():
+				click.echo(result.stdout.strip())
+			return
+		stderr = (result.stderr or "").strip()
+		errors.append(f"$ {' '.join(command)}\n{stderr}")
+
+	raise click.ClickException(
+		"Failed to run licenseheaders. Ensure it is installed in the current environment.\n\n"
+		+ "\n\n".join(errors)
+	)

{plesty_sdk-0.0.2.dev6 → plesty_sdk-0.0.2.dev10}/pyproject.toml

@@ -17,9 +17,15 @@ dependencies = [
     "sphinx-external-toc>=1.1.0",
     "sphinxcontrib-mermaid>=2.0.0",
     "watchfiles>=1.1.1",
+    "md2pdf>=3.1.1"
 ]
 dynamic = ["version"]
 
+[project.optional-dependencies]
+pdf = [
+    "md2pdf>=3.1.1",
+]
+
 [project.scripts]
 plesty = "plesty_sdk.cli:app"
 

plesty_sdk-0.0.2.dev6/plesty_sdk/cli.py

@@ -1,32 +0,0 @@
-"""CLI tool."""
-
-# Copyright (C) 2025, 2026 Christopher Borchers, fvrehlinger, Maximilian
-# Heller, Michael Zopf (names in alphabetic order wrt. surnames)
-#
-# This file is part of plesty-sdk which is part of the Plesty library.
-#
-# plesty-sdk is free software: you can redistribute it and/or modify it under
-# the terms of the GNU Lesser General Public License as published by the Free
-# Software Foundation, either version 3 of the License, or (at your option) any
-# later version.
-#
-# plesty-sdk is distributed in the hope that it will be useful, but WITHOUT ANY
-# WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A
-# PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.
-#
-# You should have received a copy of the GNU Lesser General Public License along
-# with plesty-sdk. If not, see <https://www.gnu.org/licenses/>.
-
-import click
-
-from plesty_sdk.commands.check import check_command
-from plesty_sdk.commands.docs import docs_command
-
-
-@click.group("plesty")
-def app():
-    """The Plesty CLI tool."""
-
-
-app.add_command(check_command)
-app.add_command(docs_command)