RepoPlone 1.0.0__py3-none-any.whl

repoplone/__init__.py

@@ -0,0 +1,17 @@
+import logging
+
+
+__version__ = "1.0.0"
+
+
+PACKAGE_NAME = "repoplone"
+
+
+def _setup_logging():
+    logger = logging.getLogger(PACKAGE_NAME)
+    logger.addHandler(logging.StreamHandler())
+    logger.setLevel(logging.INFO)
+    return logger
+
+
+logger = _setup_logging()

repoplone/_types/__init__.py

@@ -0,0 +1,43 @@
+from .package import MrsDeveloperEntry
+from .package import PackageConstraintInfo
+from .package import Requirements
+from .package import VersionChecker
+from .package import VersionUpgrader
+from .pipeline import PipelineReleaseStep
+from .pipeline import PipelineReleaseStepFunction
+from .pipeline import PipelineState
+from .repository import BackendPackage
+from .repository import Changelogs
+from .repository import FrontendPackage
+from .repository import Package
+from .repository import RepositorySettings
+from .repository import TowncrierSection
+from .repository import TowncrierSettings
+from dataclasses import dataclass
+
+
+@dataclass
+class CTLContextObject:
+    """Context object used by cli."""
+
+    settings: RepositorySettings
+
+
+__all__ = [
+    "BackendPackage",
+    "CTLContextObject",
+    "Changelogs",
+    "FrontendPackage",
+    "MrsDeveloperEntry",
+    "Package",
+    "PackageConstraintInfo",
+    "PipelineReleaseStep",
+    "PipelineReleaseStepFunction",
+    "PipelineState",
+    "RepositorySettings",
+    "Requirements",
+    "TowncrierSection",
+    "TowncrierSettings",
+    "VersionChecker",
+    "VersionUpgrader",
+]

repoplone/_types/package.py

@@ -0,0 +1,40 @@
+from .repository import RepositorySettings
+from packaging.requirements import Requirement
+from typing import NotRequired
+from typing import Protocol
+from typing import TypedDict
+
+
+Requirements = dict[str, Requirement]
+
+
+class PackageConstraintInfo(TypedDict):
+    """Definition on a Package constraint information."""
+
+    type: str
+    url: str
+    warning: NotRequired[str]
+
+
+class VersionChecker(Protocol):
+    """Protocol for version checkers."""
+
+    def __call__(self, settings: RepositorySettings) -> tuple[str, str, str]: ...
+
+
+class VersionUpgrader(Protocol):
+    """Protocol for version upgraders."""
+
+    def __call__(self, settings: RepositorySettings, version: str) -> bool: ...
+
+
+class MrsDeveloperEntry(TypedDict):
+    """Definition of a mrs.developer.json entry."""
+
+    package: str
+    url: str
+    https: str
+    tag: str
+    output: NotRequired[str]
+    filterBlobs: bool
+    develop: bool

repoplone/_types/pipeline.py

@@ -0,0 +1,38 @@
+from dataclasses import dataclass
+from dataclasses import field
+from repoplone._types.repository import RepositorySettings
+from typing import Any
+from typing import Protocol
+
+
+@dataclass
+class PipelineState:
+    """A run of the pipeline."""
+
+    dry_run: bool = False
+    version_format: str = "semver"
+    original_version: str = ""
+    next_version: str = ""
+    steps_current: int = 0
+    steps_total: int = 0
+
+
+class PipelineReleaseStepFunction(Protocol):
+    def __call__(
+        self,
+        step_id: str,
+        title: str,
+        settings: RepositorySettings,
+        state: PipelineState,
+        **kwargs: Any,
+    ) -> bool: ...
+
+
+@dataclass
+class PipelineReleaseStep:
+    """Definition of a release step."""
+
+    id: str
+    title: str
+    func: PipelineReleaseStepFunction
+    kwargs: dict[str, Any] = field(default_factory=dict)

repoplone/_types/repository.py

@@ -0,0 +1,134 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from dataclasses import field
+from packaging.requirements import Requirement
+from pathlib import Path
+from typing import TYPE_CHECKING
+
+
+if TYPE_CHECKING:
+    from repoplone._types.pipeline import PipelineReleaseStep
+
+
+Requirements = dict[str, Requirement]
+
+
+@dataclass
+class Changelogs:
+    """Changelog locations."""
+
+    root: Path
+    backend: Path
+    frontend: Path
+
+    def sanity(self) -> bool:
+        return self.root.exists()
+
+
+@dataclass
+class Package:
+    """Package information."""
+
+    enabled: bool
+    name: str
+    path: Path
+    changelog: Path
+    towncrier: Path
+    base_package: str
+    code_path: Path
+    base_package_version: str = ""
+    publish: bool = True
+    version: str = ""
+
+    def sanity(self) -> bool:
+        if not self.enabled:
+            return True
+        return (
+            self.path.exists() and self.changelog.exists() and self.towncrier.exists()
+        )
+
+
+@dataclass
+class BackendPackage(Package):
+    """Backend package information."""
+
+    managed_by_uv: bool = False
+    python_version: str = ""
+    python_versions: list[str] = field(default_factory=list)
+    plone_versions: list[str] = field(default_factory=list)
+
+
+@dataclass
+class FrontendPackage(Package):
+    """Frontend package information."""
+
+    volto_version: str = ""
+
+
+@dataclass
+class TowncrierSection:
+    """Towncrier section."""
+
+    section_id: str
+    name: str
+    path: Path
+
+    def sanity(self) -> bool:
+        return self.path.exists() if self.path else False
+
+
+@dataclass
+class TowncrierSettings:
+    """Towncrier settings."""
+
+    sections: list[TowncrierSection]
+
+    def __getattr__(self, name: str):
+        for section in self.sections:
+            if section.section_id == name:
+                return section
+        raise AttributeError(f"{name} not found")
+
+    def sanity(self) -> bool:
+        sections = self.sections
+        checks = [section.sanity() for section in sections]
+        return all(checks)
+
+
+@dataclass
+class RepositorySettings:
+    """Settings for a distribution."""
+
+    name: str
+    managed_by_uv: bool
+    root_path: Path
+    version: str
+    version_format: str
+    container_images_prefix: str
+    backend: BackendPackage
+    frontend: FrontendPackage
+    version_path: Path
+    compose_path: list[Path]
+    towncrier: TowncrierSettings
+    changelogs: Changelogs
+    release_steps: list[PipelineReleaseStep] = field(default_factory=list)
+    remote_origin: str = ""
+    issues_url: str = ""
+    _tmp_changelog: str = ""
+
+    @property
+    def path(self) -> Path:
+        return self.root_path
+
+    def sanity(self) -> bool:
+        steps = [
+            self.root_path.exists(),
+            self.backend.sanity(),
+            self.frontend.sanity(),
+            self.version_path.exists(),
+            all(path.exists() for path in self.compose_path),
+            self.towncrier.sanity(),
+            self.changelogs.sanity(),
+        ]
+        return all(steps)

repoplone/app.py

@@ -0,0 +1,20 @@
+from repoplone.exceptions import RepoPloneException
+
+import sys
+import typer
+
+
+class RepoPlone(typer.Typer):
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+
+    def __call__(self, *args, **kwargs):
+        try:
+            super().__call__(*args, **kwargs)
+        except typer.Exit as exc:
+            sys.exit(exc.exit_code)
+        except RepoPloneException as exc:
+            typer.echo(f"Error: {exc.message}", err=True)
+            sys.exit(1)
+        except Exception as exc:
+            raise exc

repoplone/cli.py

@@ -0,0 +1,75 @@
+from repoplone import __version__
+from repoplone import _types as t
+from repoplone.app import RepoPlone
+from repoplone.commands.changelog import app as app_changelog
+from repoplone.commands.dependencies import app as app_deps
+from repoplone.commands.release import app as app_release
+from repoplone.commands.settings import app as app_settings
+from repoplone.commands.versions import app as app_versions
+from repoplone.settings import get_settings
+from typing import Annotated
+
+import typer
+
+
+app = RepoPlone(no_args_is_help=True)
+
+
+@app.callback(invoke_without_command=True)
+def main(
+    ctx: typer.Context,
+    version: Annotated[
+        bool, typer.Option(help="Report the version of this app.")
+    ] = False,
+):
+    """Welcome to Plone Repository Helper."""
+    if version:
+        typer.echo(f"repoplone {__version__}")
+        return
+    try:
+        settings = get_settings()
+    except RuntimeError:
+        typer.echo("Did not find a repository.toml file.")
+        raise typer.Exit() from None
+    ctx_obj = t.CTLContextObject(settings=settings)
+    ctx.obj = ctx_obj
+    ctx.ensure_object(t.CTLContextObject)
+
+
+app.add_typer(
+    app_changelog,
+    name="changelog",
+    no_args_is_help=False,
+    help="Displays a draft of Change log entries",
+)
+app.add_typer(
+    app_release,
+    name="release",
+    no_args_is_help=False,
+    help="Release packages in this repository",
+)
+app.add_typer(
+    app_deps,
+    name="deps",
+    no_args_is_help=True,
+    help="Check and manage dependencies",
+)
+app.add_typer(
+    app_settings,
+    name="settings",
+    no_args_is_help=True,
+    help="Manage settings for a repository",
+)
+app.add_typer(
+    app_versions,
+    name="versions",
+    no_args_is_help=True,
+    help="Display version information about this repository",
+)
+
+
+def cli():
+    app()
+
+
+__all__ = ["cli"]

repoplone/commands/changelog.py

@@ -0,0 +1,23 @@
+from repoplone import _types as t
+from repoplone.app import RepoPlone
+from repoplone.utils import changelog as chgutils
+from repoplone.utils import display as dutils
+
+import typer
+
+
+app = RepoPlone()
+
+
+@app.callback(invoke_without_command=True)
+def main(
+    ctx: typer.Context,
+):
+    """Generate a draft of the final changelog."""
+    settings: t.RepositorySettings = ctx.obj.settings
+    original_version = settings.version
+    # Changelog
+    new_entries, _ = chgutils.update_changelog(
+        settings, draft=True, version=original_version
+    )
+    dutils.print(f"{'=' * 50}\n{new_entries}\n{'=' * 50}")

repoplone/commands/dependencies/__init__.py

@@ -0,0 +1,211 @@
+from repoplone import _types as t
+from repoplone import logger
+from repoplone import utils
+from repoplone.app import RepoPlone
+from repoplone.integrations.make import Make
+from repoplone.utils import dependencies
+from repoplone.utils import display as dutils
+from typing import Annotated
+
+import typer
+
+
+app = RepoPlone()
+
+
+@app.command()
+def info(ctx: typer.Context):
+    """Report the base packages in use."""
+    settings: t.RepositorySettings = ctx.obj.settings
+    title = "Base packages"
+    cols = [
+        {"header": "Component"},
+        {"header": "Package Name"},
+    ]
+    rows = []
+    if settings.backend.enabled:
+        rows.append(["Backend", settings.backend.base_package])
+    if settings.frontend.enabled:
+        rows.append(["Frontend", settings.frontend.base_package])
+    table = dutils.table(title, cols, rows)
+    dutils.print(table)
+
+
+@app.command()
+def check(ctx: typer.Context):
+    """Check latest version of base package and compare it to our current pinning."""
+    settings: t.RepositorySettings = ctx.obj.settings
+    title = "Base packages versions"
+    cols = [
+        {"header": "Component"},
+        {"header": "Package Name"},
+        {"header": "Current Version"},
+        {"header": "Latest Version"},
+    ]
+    rows = []
+    if settings.backend.enabled:
+        backend_versions = dependencies.check_backend_base_package(settings)
+        rows.append(["Backend", *backend_versions])
+    if settings.frontend.enabled:
+        frontend_versions = dependencies.check_frontend_base_package(settings)
+        rows.append(["Frontend", *frontend_versions])
+    table = dutils.table(title, cols, rows)
+    dutils.print(table)
+
+
+def _upgrade_backend(settings: t.RepositorySettings, version: str) -> bool:
+    """Upgrade a base dependency to a newer version."""
+    package_name: str = settings.backend.base_package
+    logger.info(f"Getting {package_name} constraints for version {version}")
+    pyproject_path = utils.get_pyproject(settings)
+    if pyproject_path:
+        status = dependencies.update_backend_constraints(
+            settings, pyproject_path, package_name, version
+        )
+        # Update versions.txt if it exists
+        backend_path = settings.backend.path
+        version_file = (backend_path / "version.txt").resolve()
+        if status and version_file.exists():
+            version_file.write_text(f"{version}\n")
+        return status
+    else:
+        return False
+
+
+def _upgrade_frontend(settings: t.RepositorySettings, version: str) -> bool:
+    """Upgrade a base dependency to a newer version."""
+    package_name: str = settings.frontend.base_package
+    return dependencies.update_frontend_base_package(settings, package_name, version)
+
+
+def _sync_dependencies(settings: t.RepositorySettings, component: str):
+    """Sync the lockfile for a specific component."""
+    path = settings.backend.path if component == "backend" else settings.frontend.path
+    towncrier_path = path / "news"
+    make = Make(settings.root_path)
+    try:
+        target = f"{component}-install"
+        typer.echo(f" - Will update lockfile by running 'make {target}'")
+        make.run(target)
+    except RuntimeError as e:
+        typer.echo(f" - Error running 'make {target}: {e}")
+        raise typer.Exit(1) from e
+    typer.echo("\n")
+    typer.echo(f"Now, please, add a news entry in {towncrier_path}.")
+
+
+@app.command()
+def constraints(
+    ctx: typer.Context,
+    component: Annotated[
+        str,
+        typer.Argument(help="Which component to update constraints?"),
+    ] = "backend",
+):
+    """Update constraints for a specific component."""
+    settings: t.RepositorySettings = ctx.obj.settings
+    if component not in ("backend"):
+        typer.echo("Component must be 'backend'.")
+        raise typer.Exit(1)
+    managed_by_uv = settings.backend.managed_by_uv
+    pyproject_path = utils.get_pyproject(settings)
+    if managed_by_uv and pyproject_path:
+        info = dependencies.check_backend_base_package(settings)
+        package_name, version = info[0:2]
+        dependencies.update_backend_constraints(
+            settings, pyproject_path, package_name, version
+        )
+        typer.echo("Updated constraints in pyproject.toml.")
+    else:
+        typer.echo("Only available in projects managed by uv (pyproject.toml).")
+
+
+@app.command()
+def sync(
+    ctx: typer.Context,
+    component: Annotated[
+        str,
+        typer.Argument(
+            help="Which component to sync the lockfile? backend or frontend"
+        ),
+    ] = "both",
+):
+    """Sync the lockfile for a specific component."""
+    settings: t.RepositorySettings = ctx.obj.settings
+    if component not in ("backend", "frontend", "both"):
+        typer.echo("Component must be either 'backend' or 'frontend'.")
+        raise typer.Exit(1)
+
+    components = []
+    if component == "both":
+        if settings.backend.enabled:
+            components.append("backend")
+        if settings.frontend.enabled:
+            components.append("frontend")
+    else:
+        # Check if component is enabled
+        section = getattr(settings, component)
+        if not section.enabled:
+            typer.echo(
+                f"Error: {component.title()} component is not enabled "
+                "in repository.toml"
+            )
+            raise typer.Exit(1)
+        components = [component]
+
+    for component_ in components:
+        _sync_dependencies(settings, component_)
+        typer.echo("\n")
+
+
+UPGRADE_FUNC: dict[str, tuple[t.VersionChecker, t.VersionUpgrader]] = {
+    "backend": (dependencies.check_backend_base_package, _upgrade_backend),
+    "frontend": (dependencies.check_frontend_base_package, _upgrade_frontend),
+}
+
+
+@app.command()
+def upgrade(
+    ctx: typer.Context,
+    component: Annotated[
+        str, typer.Argument(help="Which component to upgrade? backend or frontend?")
+    ],
+    version: Annotated[
+        str, typer.Argument(help="New version the base package")
+    ] = "latest",
+):
+    """Upgrade a base dependency to a newer version."""
+    settings: t.RepositorySettings = ctx.obj.settings
+    if component not in ("backend", "frontend"):
+        typer.echo("Component must be either 'backend' or 'frontend'.")
+        raise typer.Exit(1)
+
+    # Check if component is enabled
+    section = getattr(settings, component)
+    if not section.enabled:
+        typer.echo(
+            f"Error: {component.title()} component is not enabled in repository.toml"
+        )
+        raise typer.Exit(1)
+
+    info_func, upgrade_func = UPGRADE_FUNC[component]
+
+    try:
+        info = info_func(settings)
+    except RuntimeError as e:
+        typer.echo(f" - Error checking {component} base package: {e}")
+        raise typer.Exit(1) from e
+    package_name, current_version = info[0:2]
+    if version == "latest":
+        version = info[2]  # Latest version
+    package_title = f"{package_name} ({component.title()})"
+    if version != current_version:
+        typer.echo(f"Upgrade {package_title} from {current_version} to {version}")
+        if upgrade_func(settings, version):
+            typer.echo(f"- {package_title} at version {version}.")
+            _sync_dependencies(settings, component)
+        else:
+            typer.echo(f"- Failed to upgrade {package_title} to version {version}.")
+            raise typer.Exit(1)
+    else:
+        typer.echo(f"{package_title} already at version {version}.")

repoplone/commands/release.py

@@ -0,0 +1,64 @@
+from repoplone import _types as t
+from repoplone.app import RepoPlone
+from repoplone.release.pipeline import ReleasePipeline
+from repoplone.utils import display as dutils
+from repoplone.utils import release as utils
+from typing import Annotated
+
+import typer
+
+
+app = RepoPlone()
+
+
+NO_VERSION: str = "next"
+
+
+def _preflight_check(settings: t.RepositorySettings) -> bool:
+    """Check if the repository is ready for a release."""
+    status: bool = True
+    sanity = utils.sanity_check(settings)
+
+    if sanity.warnings:
+        dutils.print("\n[bold yellow]Warnings:[/bold yellow]")
+        for warning in sanity.warnings:
+            dutils.print(f"- [yellow]{warning}[/yellow]")
+
+    if sanity.errors:
+        dutils.print("\n[bold red]Errors:[/bold red]")
+        for error in sanity.errors:
+            dutils.print(f"- [red]{error}[/red]")
+        raise typer.Exit(1)
+
+    if sanity.warnings:
+        status = dutils.check_confirm("Do you want to continue the release?")
+    return status
+
+
+@app.callback(invoke_without_command=True)
+def main(
+    ctx: typer.Context,
+    desired_version: Annotated[
+        str,
+        typer.Argument(
+            help=(
+                "Next version. Could be the version number, or "
+                "a segment like: a, minor, major, rc"
+            ),
+        ),
+    ] = NO_VERSION,
+    dry_run: Annotated[bool, typer.Option(help="Is this a dry run?")] = False,
+):
+    """Release the packages in this repository."""
+    settings: t.RepositorySettings = ctx.obj.settings
+    dutils.print(f"\n[bold green]Release {settings.name}[/bold green]")
+    if not _preflight_check(settings):
+        raise typer.Exit(0)
+    pipeline = ReleasePipeline(settings, dry_run, desired_version)
+    try:
+        pipeline()
+    except RuntimeError as e:
+        dutils.print(f"\n[bold red]Release failed: {e}[/bold red]")
+        raise typer.Exit(1) from e
+
+    raise typer.Exit(0)