lange-python 0.1.0__tar.gz → 0.2.0__tar.gz

{lange_python-0.1.0 → lange_python-0.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lange-python
-Version: 0.1.0
+Version: 0.2.0
 Summary: A bundeld set of tools, clients for the lange-suite of tools and more.
 Author: contact@robertlange.me
 Requires-Python: >=3.13

lange_python-0.2.0/lange/cli/__init__.py

@@ -0,0 +1,20 @@
+"""CLI commands for the ``lange`` Python package."""
+
+from __future__ import annotations
+from .code import code_group
+from .build import build_command
+
+import click
+
+
+
+@click.group()
+def cli() -> None:
+    """
+    Lange CLI entrypoint.
+
+    :returns: ``None``.
+    """
+
+cli.add_command(code_group, "code")
+cli.add_command(build_command, "build")

lange_python-0.2.0/lange/cli/build/__init__.py

@@ -0,0 +1,5 @@
+"""Public exports for ``lange build`` command helpers."""
+
+from ._command import build_command
+
+__all__ = ["build_command"]

lange_python-0.2.0/lange/cli/build/_command.py

@@ -0,0 +1,158 @@
+"""CLI command orchestration for ``lange build``."""
+
+from __future__ import annotations
+
+import subprocess
+from pathlib import Path
+
+import click
+
+from ._discovery import (
+    detect_available_build_systems,
+    prompt_for_build_system_selection,
+    resolve_build_folder,
+)
+from ._docker import ensure_docker_is_available, parse_image_reference, run_docker_build
+from ._poetry import run_poetry_build, run_poetry_publish
+from ._types import DOCKER_BUILD_SYSTEM, POETRY_BUILD_SYSTEM, BuildSystem
+
+
+@click.command("build")
+@click.argument("folder_name", required=False)
+@click.option("--publish", is_flag=True, help="Publish after a successful build.")
+@click.option("--docker", "force_docker", is_flag=True, help="Force docker build.")
+@click.option("--poetry", "force_poetry", is_flag=True, help="Force poetry build.")
+def build_command(
+    folder_name: str | None,
+    publish: bool,
+    force_docker: bool,
+    force_poetry: bool,
+) -> None:
+    """
+    Build a folder using docker or poetry with optional publishing.
+
+    :param folder_name: Optional folder name to build.
+    :param publish: Whether publishing is enabled via flag.
+    :param force_docker: Force docker build system.
+    :param force_poetry: Force poetry build system.
+    :returns: ``None``.
+    """
+    _validate_force_flags(force_docker=force_docker, force_poetry=force_poetry)
+
+    target_folder = resolve_build_folder(folder_name=folder_name, root=Path.cwd())
+    build_system = resolve_build_system(
+        folder=target_folder,
+        force_docker=force_docker,
+        force_poetry=force_poetry,
+    )
+
+    if build_system == DOCKER_BUILD_SYSTEM:
+        _run_docker_flow(folder=target_folder, publish=publish)
+        return
+
+    _run_poetry_flow(folder=target_folder, publish=publish)
+
+
+def _validate_force_flags(force_docker: bool, force_poetry: bool) -> None:
+    """
+    Validate that at most one build-system force flag is provided.
+
+    :param force_docker: Whether docker was forced.
+    :param force_poetry: Whether poetry was forced.
+    :returns: ``None``.
+    """
+    if force_docker and force_poetry:
+        raise click.ClickException("Only one of --docker or --poetry can be used.")
+
+
+def resolve_build_system(
+    folder: Path,
+    force_docker: bool,
+    force_poetry: bool,
+) -> BuildSystem:
+    """
+    Resolve the build system from force flags or discovered files.
+
+    :param folder: Folder that should be built.
+    :param force_docker: Whether docker was forced.
+    :param force_poetry: Whether poetry was forced.
+    :returns: Resolved build system value.
+    """
+    if force_docker:
+        dockerfile = folder / "Dockerfile"
+        if not dockerfile.is_file():
+            raise click.ClickException(
+                f"Dockerfile was not found at '{dockerfile}'."
+            )
+        return DOCKER_BUILD_SYSTEM
+
+    if force_poetry:
+        pyproject_file = folder / "pyproject.toml"
+        if not pyproject_file.is_file():
+            raise click.ClickException(
+                f"pyproject.toml was not found at '{pyproject_file}'."
+            )
+        return POETRY_BUILD_SYSTEM
+
+    detected_systems = detect_available_build_systems(folder)
+    if not detected_systems:
+        raise click.ClickException(
+            "Could not detect a supported build system. "
+            "Expected Dockerfile and/or pyproject.toml."
+        )
+    if len(detected_systems) == 1:
+        return detected_systems[0]
+    return prompt_for_build_system_selection(detected_systems)
+
+
+def _run_docker_flow(folder: Path, publish: bool) -> None:
+    """
+    Run docker build flow and optional publish flow.
+
+    :param folder: Folder to build.
+    :param publish: Whether publish was requested via flag.
+    :returns: ``None``.
+    """
+    dockerfile = folder / "Dockerfile"
+    image_reference = parse_image_reference(dockerfile)
+    ensure_docker_is_available()
+
+    try:
+        run_docker_build(folder=folder, image_reference=image_reference, publish=publish)
+        if not publish and _confirm_publish():
+            run_docker_build(folder=folder, image_reference=image_reference, publish=True)
+    except subprocess.CalledProcessError as error:
+        raise click.ClickException(
+            f"Docker command failed with exit code {error.returncode}."
+        ) from error
+    except OSError as error:
+        raise click.ClickException(str(error)) from error
+
+
+def _run_poetry_flow(folder: Path, publish: bool) -> None:
+    """
+    Run poetry build flow and optional publish flow.
+
+    :param folder: Folder to build.
+    :param publish: Whether publish was requested via flag.
+    :returns: ``None``.
+    """
+    try:
+        run_poetry_build(folder=folder)
+        if publish or _confirm_publish():
+            run_poetry_publish(folder=folder)
+    except subprocess.CalledProcessError as error:
+        raise click.ClickException(
+            f"Poetry command failed with exit code {error.returncode}."
+        ) from error
+    except OSError as error:
+        raise click.ClickException(str(error)) from error
+
+
+def _confirm_publish() -> bool:
+    """
+    Ask whether the built artifact should be published.
+
+    :returns: ``True`` when publish was confirmed.
+    """
+    return click.confirm("Build finished. Publish now?", default=False)

lange_python-0.2.0/lange/cli/build/_discovery.py

@@ -0,0 +1,105 @@
+"""Folder and build-system discovery helpers for ``lange build``."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+import click
+
+from ._types import DOCKER_BUILD_SYSTEM, POETRY_BUILD_SYSTEM, BuildSystem
+
+
+def list_candidate_folders(root: Path) -> list[Path]:
+    """
+    List top-level non-hidden directories.
+
+    :param root: Directory that should be scanned.
+    :returns: Sorted non-hidden child directories.
+    """
+    candidates = [
+        path
+        for path in root.iterdir()
+        if path.is_dir() and not path.name.startswith(".")
+    ]
+    return sorted(candidates, key=lambda item: item.name.lower())
+
+
+def prompt_for_folder_selection(folders: list[Path]) -> Path:
+    """
+    Prompt the user to choose one folder from candidates.
+
+    :param folders: Selectable folders.
+    :returns: Selected folder path.
+    """
+    if not folders:
+        raise click.ClickException(
+            "No selectable folders were found in the current directory."
+        )
+
+    click.echo("Choose a folder to build:")
+    for index, folder in enumerate(folders, start=1):
+        click.echo(f"{index}. {folder.name}")
+
+    selection = click.prompt(
+        "Selection",
+        type=click.IntRange(min=1, max=len(folders)),
+    )
+    return folders[selection - 1]
+
+
+def resolve_build_folder(folder_name: str | None, root: Path) -> Path:
+    """
+    Resolve the build folder from argument value or interactive selection.
+
+    :param folder_name: Optional folder argument passed via CLI.
+    :param root: Current working directory.
+    :returns: Target folder for the build.
+    """
+    if folder_name:
+        folder = (root / folder_name).resolve()
+        if not folder.exists() or not folder.is_dir():
+            raise click.ClickException(
+                f"Folder '{folder_name}' was not found or is not a directory."
+            )
+        return folder
+
+    folders = list_candidate_folders(root)
+    return prompt_for_folder_selection(folders).resolve()
+
+
+def detect_available_build_systems(folder: Path) -> list[BuildSystem]:
+    """
+    Detect supported build systems available in the given folder.
+
+    :param folder: Folder that should be inspected.
+    :returns: Ordered list of detected build systems.
+    """
+    available: list[BuildSystem] = []
+    if (folder / "Dockerfile").is_file():
+        available.append(DOCKER_BUILD_SYSTEM)
+    if (folder / "pyproject.toml").is_file():
+        available.append(POETRY_BUILD_SYSTEM)
+    return available
+
+
+def prompt_for_build_system_selection(
+    available_systems: list[BuildSystem],
+) -> BuildSystem:
+    """
+    Prompt user for a build-system selection.
+
+    :param available_systems: Selectable build systems.
+    :returns: Selected build system.
+    """
+    if not available_systems:
+        raise click.ClickException("No build systems were provided for selection.")
+
+    click.echo("Multiple build systems detected. Choose one:")
+    for index, system in enumerate(available_systems, start=1):
+        click.echo(f"{index}. {system}")
+
+    selection = click.prompt(
+        "Selection",
+        type=click.IntRange(min=1, max=len(available_systems)),
+    )
+    return available_systems[selection - 1]

lange_python-0.2.0/lange/cli/build/_docker.py

@@ -0,0 +1,127 @@
+"""Docker-specific build helpers for ``lange build``."""
+
+from __future__ import annotations
+
+import re
+import shutil
+import subprocess
+from pathlib import Path
+
+import click
+
+BUILDER_NAME = "services-multiarch"
+PLATFORMS = "linux/amd64,linux/arm64"
+IMAGE_LINE_PATTERN = re.compile(r"^#\s*image:\s*(?P<image>\S+)\s*$", re.IGNORECASE)
+
+
+def ensure_docker_is_available() -> None:
+    """
+    Validate that docker is installed and available in ``PATH``.
+
+    :returns: ``None``.
+    """
+    if shutil.which("docker") is None:
+        raise click.ClickException("docker is not installed or not available in PATH.")
+
+
+def parse_image_reference(dockerfile_path: Path) -> str:
+    """
+    Parse and normalize image reference from Dockerfile first line.
+
+    :param dockerfile_path: Dockerfile path to parse.
+    :returns: Docker image reference including tag.
+    """
+    first_line = dockerfile_path.read_text(encoding="utf-8").splitlines()[:1]
+    if not first_line:
+        raise click.ClickException(
+            "Dockerfile must start with '# image: <name>' as first line."
+        )
+
+    match = IMAGE_LINE_PATTERN.match(first_line[0].strip())
+    if match is None:
+        raise click.ClickException(
+            "Dockerfile must start with '# image: <name>' as first line."
+        )
+
+    image_reference = match.group("image").strip()
+    if not image_reference:
+        raise click.ClickException(
+            "Dockerfile must start with '# image: <name>' as first line."
+        )
+
+    if "@" in image_reference or _has_explicit_tag(image_reference):
+        return image_reference
+    return f"{image_reference}:latest"
+
+
+def _has_explicit_tag(image_reference: str) -> bool:
+    """
+    Check whether an image reference already contains a tag component.
+
+    :param image_reference: Docker image reference.
+    :returns: ``True`` when the final path segment contains a tag.
+    """
+    trailing_segment = image_reference.rsplit("/", maxsplit=1)[-1]
+    return ":" in trailing_segment
+
+
+def ensure_buildx_builder() -> None:
+    """
+    Ensure the configured docker buildx builder exists and is active.
+
+    :returns: ``None``.
+    """
+    inspect_result = subprocess.run(
+        ["docker", "buildx", "inspect", BUILDER_NAME],
+        check=False,
+        stdout=subprocess.DEVNULL,
+        stderr=subprocess.DEVNULL,
+    )
+
+    if inspect_result.returncode != 0:
+        subprocess.run(
+            ["docker", "buildx", "create", "--name", BUILDER_NAME, "--use"],
+            check=True,
+            stdout=subprocess.DEVNULL,
+        )
+    else:
+        subprocess.run(
+            ["docker", "buildx", "use", BUILDER_NAME],
+            check=True,
+            stdout=subprocess.DEVNULL,
+        )
+
+    subprocess.run(
+        ["docker", "buildx", "inspect", "--bootstrap"],
+        check=True,
+        stdout=subprocess.DEVNULL,
+    )
+
+
+def run_docker_build(folder: Path, image_reference: str, publish: bool) -> None:
+    """
+    Execute docker buildx build for the given folder.
+
+    :param folder: Build context folder.
+    :param image_reference: Docker image name including tag.
+    :param publish: Whether ``--push`` should be included.
+    :returns: ``None``.
+    """
+    dockerfile = (folder / "Dockerfile").resolve()
+    ensure_buildx_builder()
+
+    command: list[str] = [
+        "docker",
+        "buildx",
+        "build",
+        "--platform",
+        PLATFORMS,
+        "--file",
+        str(dockerfile),
+        "--tag",
+        image_reference,
+    ]
+    if publish:
+        command.append("--push")
+    command.append(str(folder.resolve()))
+    subprocess.run(command, check=True)

lange_python-0.2.0/lange/cli/build/_poetry.py

@@ -0,0 +1,26 @@
+"""Poetry-specific build helpers for ``lange build``."""
+
+from __future__ import annotations
+
+import subprocess
+from pathlib import Path
+
+
+def run_poetry_build(folder: Path) -> None:
+    """
+    Run ``poetry build`` in the target folder.
+
+    :param folder: Target folder containing ``pyproject.toml``.
+    :returns: ``None``.
+    """
+    subprocess.run(["poetry", "build"], check=True, cwd=folder)
+
+
+def run_poetry_publish(folder: Path) -> None:
+    """
+    Run ``poetry publish`` in the target folder.
+
+    :param folder: Target folder containing ``pyproject.toml``.
+    :returns: ``None``.
+    """
+    subprocess.run(["poetry", "publish"], check=True, cwd=folder)

lange_python-0.2.0/lange/cli/build/_types.py

@@ -0,0 +1,10 @@
+"""Shared build command type definitions."""
+
+from __future__ import annotations
+
+from typing import Literal
+
+BuildSystem = Literal["docker", "poetry"]
+
+DOCKER_BUILD_SYSTEM: BuildSystem = "docker"
+POETRY_BUILD_SYSTEM: BuildSystem = "poetry"

lange_python-0.2.0/lange/cli/code/__init__.py

@@ -0,0 +1,13 @@
+import click
+
+from ._stats import code_stats
+
+@click.group()
+def code_group() -> None:
+    """
+    Group for source-code related commands.
+
+    :returns: ``None``.
+    """
+
+code_group.add_command(code_stats,"code_stats")

lange_python-0.2.0/lange/cli/code/_stats.py

@@ -0,0 +1,81 @@
+from pathlib import Path
+from typing import Iterable
+import os
+import click
+
+SUPPORTED_EXTENSIONS: tuple[str, ...] = (".py", ".tsx", ".js", ".jsx", ".ts", ".html", ".css")
+IGNORED_DIRECTORIES: tuple[str, ...] = (".venv", "node_modules", ".git", ".next")
+
+
+def _render_stats_table(stats: dict[str, int]) -> str:
+    """
+    Render LOC statistics as an ASCII box table.
+
+    :param stats: Mapping from file ending to line count.
+    :returns: Table string with file type, LOC and percentage values.
+    """
+    total = sum(stats.values())
+    rows: list[tuple[str, str, str]] = []
+
+    for extension, loc in sorted(stats.items(), key=lambda item: (-item[1], item[0])):
+        percentage = (loc / total * 100.0) if total else 0.0
+        rows.append((extension, str(loc), f"{percentage:.2f}%"))
+
+    total_percentage = 100.0 if total else 0.0
+    rows.append(("TOTAL", str(total), f"{total_percentage:.2f}%"))
+
+    headers = ("File-Type", "LOC", "Percentage")
+    col_widths = [
+        max(len(headers[index]), max((len(row[index]) for row in rows), default=0))
+        for index in range(3)
+    ]
+
+    border = "+" + "+".join("-" * (width + 2) for width in col_widths) + "+"
+
+    def _render_row(values: tuple[str, str, str]) -> str:
+        padded = [value.ljust(col_widths[index]) for index, value in enumerate(values)]
+        return "| " + " | ".join(padded) + " |"
+
+    lines = [border, _render_row(headers), border]
+    lines.extend(_render_row(row) for row in rows)
+    lines.append(border)
+    return "\n".join(lines)
+
+def _count_lines_by_extension(root: Path, extensions: Iterable[str]) -> dict[str, int]:
+    """
+    Count file lines recursively grouped by file ending.
+
+    :param root: Directory that should be scanned recursively.
+    :param extensions: Allowed file endings, including the leading dot.
+    :returns: Mapping from file ending to counted LOC.
+    """
+    normalized_extensions = tuple(extension.lower() for extension in extensions)
+    counts = {extension: 0 for extension in normalized_extensions}
+
+    for current_root, directories, files in os.walk(root, topdown=True):
+        directories[:] = [name for name in directories if name not in IGNORED_DIRECTORIES]
+
+        for file_name in files:
+            suffix = Path(file_name).suffix.lower()
+            if suffix not in counts:
+                continue
+
+            file_path = Path(current_root) / file_name
+            with file_path.open("r", encoding="utf-8", errors="ignore") as file_handle:
+                counts[suffix] += sum(1 for _ in file_handle)
+
+    return counts
+
+@click.command("stats")
+def code_stats() -> None:
+    """
+    Print LOC statistics for the current working directory.
+
+    :returns: ``None``.
+    """
+    stats = _count_lines_by_extension(Path.cwd(), SUPPORTED_EXTENSIONS)
+    click.echo()
+    click.echo()
+    click.echo(f"Recognized file endings: {' '.join(SUPPORTED_EXTENSIONS)}")
+    click.echo(f"Ignored folders: {' '.join(IGNORED_DIRECTORIES)}")
+    click.echo(_render_stats_table(stats))

{lange_python-0.1.0 → lange_python-0.2.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "lange-python"
-version = "0.1.0"
+version = "0.2.0"
 description = "A bundeld set of tools, clients for the lange-suite of tools and more."
 authors = [
     {name = "contact@robertlange.me"}

lange_python-0.1.0/lange/cli.py

@@ -1,264 +0,0 @@
-"""CLI commands for the ``lange`` Python package."""
-
-from __future__ import annotations
-
-from collections.abc import Iterable
-import json
-import os
-from pathlib import Path
-import subprocess
-from typing import Literal, cast
-
-import click
-
-from lange.services_schema import Project, Service
-
-SUPPORTED_EXTENSIONS: tuple[str, ...] = (".py", ".tsx", ".js", ".jsx", ".ts", ".html", ".css")
-IGNORED_DIRECTORIES: tuple[str, ...] = (".venv", "node_modules", ".git", ".next")
-SERVICES_FILE_NAME = "services.json"
-
-
-def count_lines_by_extension(root: Path, extensions: Iterable[str]) -> dict[str, int]:
-    """
-    Count file lines recursively grouped by file ending.
-
-    :param root: Directory that should be scanned recursively.
-    :param extensions: Allowed file endings, including the leading dot.
-    :returns: Mapping from file ending to counted LOC.
-    """
-    normalized_extensions = tuple(extension.lower() for extension in extensions)
-    counts = {extension: 0 for extension in normalized_extensions}
-
-    for current_root, directories, files in os.walk(root, topdown=True):
-        directories[:] = [name for name in directories if name not in IGNORED_DIRECTORIES]
-
-        for file_name in files:
-            suffix = Path(file_name).suffix.lower()
-            if suffix not in counts:
-                continue
-
-            file_path = Path(current_root) / file_name
-            with file_path.open("r", encoding="utf-8", errors="ignore") as file_handle:
-                counts[suffix] += sum(1 for _ in file_handle)
-
-    return counts
-
-
-def render_stats_table(stats: dict[str, int]) -> str:
-    """
-    Render LOC statistics as an ASCII box table.
-
-    :param stats: Mapping from file ending to line count.
-    :returns: Table string with file type, LOC and percentage values.
-    """
-    total = sum(stats.values())
-    rows: list[tuple[str, str, str]] = []
-
-    for extension, loc in sorted(stats.items(), key=lambda item: (-item[1], item[0])):
-        percentage = (loc / total * 100.0) if total else 0.0
-        rows.append((extension, str(loc), f"{percentage:.2f}%"))
-
-    total_percentage = 100.0 if total else 0.0
-    rows.append(("TOTAL", str(total), f"{total_percentage:.2f}%"))
-
-    headers = ("File-Type", "LOC", "Percentage")
-    col_widths = [
-        max(len(headers[index]), max((len(row[index]) for row in rows), default=0))
-        for index in range(3)
-    ]
-
-    border = "+" + "+".join("-" * (width + 2) for width in col_widths) + "+"
-
-    def _render_row(values: tuple[str, str, str]) -> str:
-        padded = [value.ljust(col_widths[index]) for index, value in enumerate(values)]
-        return "| " + " | ".join(padded) + " |"
-
-    lines = [border, _render_row(headers), border]
-    lines.extend(_render_row(row) for row in rows)
-    lines.append(border)
-    return "\n".join(lines)
-
-
-def services_file_path(root: Path) -> Path:
-    """
-    Build the absolute path to ``services.json`` in a workspace root.
-
-    :param root: Workspace root directory.
-    :returns: Absolute path to ``services.json``.
-    """
-    return root / SERVICES_FILE_NAME
-
-
-def load_project_config(root: Path) -> Project:
-    """
-    Load a project config from ``services.json`` when available.
-
-    :param root: Workspace root directory.
-    :returns: Parsed project config. Defaults to an empty project.
-    """
-    path = services_file_path(root)
-    if not path.exists():
-        return Project(services=[])
-
-    data = json.loads(path.read_text(encoding="utf-8"))
-    return Project.model_validate(data)
-
-
-def save_project_config(root: Path, project: Project) -> Path:
-    """
-    Persist project config to ``services.json``.
-
-    :param root: Workspace root directory.
-    :param project: Project data to store.
-    :returns: Written file path.
-    """
-    path = services_file_path(root)
-    path.write_text(project.model_dump_json(indent=2) + "\n", encoding="utf-8")
-    return path
-
-
-@click.group()
-def cli() -> None:
-    """
-    Lange CLI entrypoint.
-
-    :returns: ``None``.
-    """
-
-
-@cli.group()
-def code() -> None:
-    """
-    Group for source-code related commands.
-
-    :returns: ``None``.
-    """
-
-
-@cli.command("init")
-def init_workspace() -> None:
-    """
-    Initialize local ``.lange`` workspace artifacts.
-
-    Creates ``.lange/.gitignore`` and ``.lange/secrets.json`` in the current
-    directory.
-
-    :returns: ``None``.
-    """
-    lange_directory = Path.cwd() / ".lange"
-    lange_directory.mkdir(parents=True, exist_ok=True)
-    gitignore_file = lange_directory / ".gitignore"
-    gitignore_file.write_text("*\n", encoding="utf-8")
-    secrets_file = lange_directory / "secrets.json"
-    secrets_file.write_text("{}\n", encoding="utf-8")
-    click.echo(f"Initialized {gitignore_file}")
-
-
-@cli.command("create")
-def create_service() -> None:
-    """
-    Interactively add a service entry to ``services.json``.
-
-    :returns: ``None``.
-    """
-    root = Path.cwd()
-    project = load_project_config(root)
-
-    name = click.prompt("Service name", type=str).strip()
-    path = click.prompt("Service path", type=str, default=".", show_default=True).strip()
-    build_type = click.prompt(
-        "Build type",
-        type=click.Choice(["docker", "pyinstall"], case_sensitive=False),
-        default="docker",
-        show_default=True,
-    ).lower()
-    publish_path_input = click.prompt("Publish path (optional)", default="", show_default=False).strip()
-
-    service = Service(
-        name=name,
-        path=path,
-        build_type=cast(Literal["docker", "pyinstall"], build_type),
-        publish_path=publish_path_input or None,
-    )
-    project.services.append(service)
-
-    config_path = save_project_config(root, project)
-    click.echo(f"Added service '{service.name}' to {config_path}")
-
-
-def _iter_services_for_build(project: Project, target_name: str | None) -> list[Service]:
-    """
-    Select services for a build operation.
-
-    :param project: Parsed project configuration.
-    :param target_name: Optional service name filter.
-    :returns: Services to build.
-    :raises click.ClickException: Raised when no services can be built.
-    """
-    if target_name is None:
-        services = project.services
-    else:
-        services = [service for service in project.services if service.name == target_name]
-
-    if not services:
-        if target_name:
-            raise click.ClickException(f"Service '{target_name}' not found in {SERVICES_FILE_NAME}.")
-        raise click.ClickException(f"No services configured in {SERVICES_FILE_NAME}.")
-
-    return services
-
-
-@cli.command("build")
-@click.argument("service_name", required=False)
-def build_services(service_name: str | None) -> None:
-    """
-    Build configured services from ``services.json``.
-
-    Only docker build logic is implemented at the moment.
-
-    :param service_name: Optional single service name to build.
-    :returns: ``None``.
-    """
-    root = Path.cwd()
-    project = load_project_config(root)
-    services = _iter_services_for_build(project, service_name)
-
-    for service in services:
-        if service.build_type != "docker":
-            click.echo(f"Skipping '{service.name}' (build_type={service.build_type} not implemented).")
-            continue
-
-        context_path = service.resolve_path(root)
-        dockerfile_path = context_path / "Dockerfile"
-        if not dockerfile_path.exists():
-            raise click.ClickException(f"Missing Dockerfile for service '{service.name}' at {dockerfile_path}")
-
-        image_name = service.publish_path or service.name
-        click.echo(f"Building '{service.name}' as image '{image_name}' from {context_path}")
-        subprocess.run(
-            [
-                "docker",
-                "build",
-                "-t",
-                image_name,
-                "-f",
-                str(dockerfile_path),
-                str(context_path),
-            ],
-            check=True,
-        )
-
-
-@code.command("stats")
-def code_stats() -> None:
-    """
-    Print LOC statistics for the current working directory.
-
-    :returns: ``None``.
-    """
-    stats = count_lines_by_extension(Path.cwd(), SUPPORTED_EXTENSIONS)
-    click.echo()
-    click.echo()
-    click.echo(f"Recognized file endings: {' '.join(SUPPORTED_EXTENSIONS)}")
-    click.echo(f"Ignored folders: {' '.join(IGNORED_DIRECTORIES)}")
-    click.echo(render_stats_table(stats))

lange_python-0.1.0/lange/services_schema.py

@@ -1,50 +0,0 @@
-"""Pydantic schemas for ``services.json`` project configuration."""
-
-from __future__ import annotations
-
-from pathlib import Path
-from typing import Literal
-
-from pydantic import BaseModel, ConfigDict
-
-
-class Service(BaseModel):
-    """
-    Service definition stored in ``services.json``.
-
-    :param name: Human-readable service name.
-    :param path: Relative or absolute directory path for this service.
-    :param build_type: Build strategy, either docker or pyinstall.
-    :param publish_path: Optional publish target or image name.
-    """
-
-    model_config = ConfigDict(extra="forbid")
-
-    name: str
-    path: str
-    build_type: Literal["docker", "pyinstall"]
-    publish_path: str | None = None
-
-    def resolve_path(self, root: Path) -> Path:
-        """
-        Resolve the service path relative to a workspace root.
-
-        :param root: Workspace root directory.
-        :returns: Absolute service path.
-        """
-        path = Path(self.path)
-        if path.is_absolute():
-            return path
-        return (root / path).resolve()
-
-
-class Project(BaseModel):
-    """
-    Project configuration for service-based operations.
-
-    :param services: Configured services in this project.
-    """
-
-    model_config = ConfigDict(extra="forbid")
-
-    services: list[Service]