python-jcli 1.0.0__py3-none-any.whl → 1.0.1__py3-none-any.whl

jcli/plugins/view.py

@@ -1,148 +0,0 @@
-"""Jenkins View management commands."""
-
-from __future__ import annotations
-
-import json
-from pathlib import Path
-
-import click
-
-from jcli.cli_helpers import get_client, get_formatter
-from jcli.sdk.view import create_view as sdk_create_view
-from jcli.sdk.view import delete_view as sdk_delete_view
-from jcli.sdk.view import get_view as sdk_get_view
-from jcli.sdk.view import list_views as sdk_list_views
-from jcli.sdk.view import update_view as sdk_update_view
-
-
-def _format_output(ctx: click.Context, data: object) -> str:
-    """Format data according to the user-specified output format."""
-    ctx_obj = ctx.obj or {}
-    fmt = ctx_obj.get("format", "table")
-
-    if fmt == "json":
-        return json.dumps(data, indent=2, ensure_ascii=False)
-
-    if fmt == "yaml":
-        import yaml
-
-        return yaml.dump(data, default_flow_style=False, allow_unicode=True)
-
-    # Default: table-like plain text
-    return str(data)
-
-
-# ------------------------------------------------------------------
-# Click command group
-# ------------------------------------------------------------------
-
-
-@click.group("view", help="Manage Jenkins views.")
-def view_group():
-    """View management commands."""
-
-
-@view_group.command("list")
-@click.pass_context
-def view_list(ctx: click.Context) -> None:
-    """List all Jenkins views."""
-    client = get_client(ctx)
-    views = sdk_list_views(client)
-
-    # Build table output
-    ctx_obj = ctx.obj or {}
-    if ctx_obj.get("format", "table") == "table":
-        if not views:
-            click.echo("No views found.")
-            return
-        for v in views:
-            job_count = len(v.get("jobs", []))
-            click.echo(f"  {v['name']} ({job_count} jobs)")
-        return
-
-    click.echo(_format_output(ctx, views))
-
-
-@view_group.command("get")
-@click.argument("view_name", metavar="NAME")
-@click.pass_context
-def view_get(ctx: click.Context, view_name: str) -> None:
-    """Get details for a Jenkins view."""
-    client = get_client(ctx)
-    data = sdk_get_view(client, view_name)
-
-    # Table output: show key fields
-    ctx_obj = ctx.obj or {}
-    if ctx_obj.get("format", "table") == "table":
-        click.echo(f"Name:        {data.get('name', view_name)}")
-        click.echo(f"URL:         {data.get('url', '')}")
-        click.echo(f"Description: {data.get('description', '')}")
-        jobs = data.get("jobs", [])
-        if jobs:
-            click.echo("Jobs:")
-            for j in jobs:
-                click.echo(f"  - {j['name']}  [{j.get('color', 'unknown')}]")
-        return
-
-    click.echo(_format_output(ctx, data))
-
-
-@view_group.command("create")
-@click.argument("view_name", metavar="NAME")
-@click.argument(
-    "config_file",
-    metavar="CONFIG_XML",
-    type=click.Path(exists=True, dir_okay=False, path_type=Path),
-)
-@click.pass_context
-def view_create(ctx: click.Context, view_name: str, config_file: Path) -> None:
-    """Create a new Jenkins view from an XML config file."""
-    xml_data = config_file.read_text(encoding="utf-8")
-
-    client = get_client(ctx)
-    sdk_create_view(client, view_name, xml_data)
-    click.echo(f"View '{view_name}' created successfully.")
-
-
-@view_group.command("update")
-@click.argument("view_name")
-@click.argument("config_file", type=click.Path(exists=True, dir_okay=False))
-@click.pass_context
-def update_view_cmd(ctx, view_name, config_file):
-    """Update a view's configuration from an XML file."""
-    client = get_client(ctx)
-    fmt = get_formatter(ctx)
-    try:
-        with open(config_file, "r", encoding="utf-8") as f:
-            config_xml = f.read()
-        sdk_update_view(client, view_name, config_xml)
-        fmt.print_success(f"View '{view_name}' updated.")
-    except Exception as exc:
-        fmt.print_error(str(exc))
-
-
-@view_group.command("delete")
-@click.argument("view_name", metavar="NAME")
-@click.option(
-    "--yes",
-    "-y",
-    is_flag=True,
-    help="Skip confirmation prompt.",
-)
-@click.pass_context
-def view_delete(ctx: click.Context, view_name: str, yes: bool) -> None:
-    """Delete a Jenkins view."""
-    if not yes:
-        click.confirm(
-            f"Are you sure you want to delete view '{view_name}'?",
-            abort=True,
-        )
-
-    client = get_client(ctx)
-    sdk_delete_view(client, view_name)
-    click.echo(f"View '{view_name}' deleted successfully.")
-
-
-def register(parent_group: click.Group) -> None:
-    """Register the view subgroup under the parent Click group."""
-    parent_group.add_command(view_group)

jcli/sdk/build.py

@@ -1,182 +0,0 @@
-"""Jenkins Build SDK — trigger, query, stop builds and manage queue."""
-
-from __future__ import annotations
-
-import time
-import urllib.parse
-from typing import Any
-
-from jcli.sdk.client import JenkinsClient
-from jcli.sdk.exceptions import JenkinsError
-
-
-def _job_path(job_name: str) -> str:
-    """Convert a job name to a Jenkins URL path segment.
-
-    Handles nested jobs (folder/sub-job) by converting each slash-separated
-    segment into ``/job/<segment>``.
-    """
-    segments = job_name.split("/")
-    return "/job/" + "/job/".join(segments)
-
-
-def trigger_build(
-    client: JenkinsClient,
-    job_name: str,
-    params: dict[str, Any] | None = None,
-) -> dict[str, Any]:
-    """Trigger a new build for the given job.
-
-    If *params* is provided the build is triggered with parameters via
-    ``/buildWithParameters``, otherwise a plain ``/build`` is used.
-    Jenkins returns a ``Location`` header pointing to the queued item.
-    This function follows that redirect and parses the queue-item JSON.
-
-    :returns: Queue item info as returned by Jenkins (dict).
-    """
-    path = _job_path(job_name)
-    if params:
-        url = f"{path}/buildWithParameters"
-        resp = client.request("POST", url, params=params, allow_redirects=False)
-    else:
-        url = f"{path}/build"
-        resp = client.request("POST", url, allow_redirects=False)
-
-    # Jenkins responds with 201 Created or 302 Found and a Location header
-    # pointing to the queue item.  Follow that URL to get the queue item JSON.
-    location = resp.headers.get("Location")
-    if location:
-        queue_path = urllib.parse.urlparse(location).path
-        # Strip the base URL prefix — client.get_json accepts an absolute path
-        if queue_path.startswith(client.base_url):
-            queue_path = queue_path[len(client.base_url) :]
-        try:
-            return client.get_json(queue_path + "api/json")
-        except JenkinsError:
-            pass
-
-    # Fallback — return a minimal dict
-    return {"status": "queued", "url": location or ""}
-
-
-def get_build(
-    client: JenkinsClient,
-    job_name: str,
-    number: int,
-) -> dict[str, Any]:
-    """Get details for a specific build.
-
-    :returns: Build details as returned by the Jenkins API.
-    """
-    path = f"{_job_path(job_name)}/{number}"
-    return client.get_json(f"{path}/api/json")
-
-
-def get_builds(
-    client: JenkinsClient,
-    job_name: str,
-    limit: int = 10,
-) -> list[dict[str, Any]]:
-    """List recent builds for a job.
-
-    :param limit: Maximum number of builds to return (applied client-side).
-    :returns: List of build dicts (trimmed to *limit*).
-    """
-    path = _job_path(job_name)
-    tree = f"builds[number,url,result,timestamp,duration,building]{f'{{{0},{limit - 1}}}' if limit > 0 else ''}"
-    data = client.get_json(f"{path}/api/json", tree=tree)
-    builds: list[dict[str, Any]] = data.get("builds", [])
-    return builds[:limit]
-
-
-def get_build_log(
-    client: JenkinsClient,
-    job_name: str,
-    number: int,
-    start: int = 0,
-) -> str:
-    """Retrieve the console log for a build.
-
-    :param start: Byte offset to start reading from (useful for polling).
-    :returns: Console log text.
-    """
-    path = f"{_job_path(job_name)}/{number}/consoleText"
-    resp = client.request("GET", path)
-    text = resp.text
-    if start > 0:
-        return text[start:]
-    return text
-
-
-def stop_build(
-    client: JenkinsClient,
-    job_name: str,
-    number: int,
-) -> dict[str, Any]:
-    """Stop (abort) a running build.
-
-    :returns: Empty dict on success.
-    """
-    path = f"{_job_path(job_name)}/{number}"
-    client.request("POST", f"{path}/stop")
-    return {}
-
-
-def get_queue(client: JenkinsClient) -> list[dict[str, Any]]:
-    """Return all items currently in the Jenkins build queue.
-
-    :returns: List of queue item dicts.
-    """
-    data = client.get_json("/queue/api/json")
-    return data.get("items", [])
-
-
-def cancel_queue_item(
-    client: JenkinsClient,
-    queue_id: int,
-) -> dict[str, Any]:
-    """Cancel a queued item.
-
-    :param queue_id: Numeric queue item ID.
-    :returns: Empty dict on success.
-    """
-    client.request("POST", "/queue/cancelItem", params={"id": queue_id})
-    return {}
-
-
-def get_build_artifacts(
-    client: JenkinsClient,
-    job_name: str,
-    build_number: int | str,
-) -> Any:
-    """Get build artifacts.
-
-    Lists artifacts produced by a build.
-    """
-    path = _job_path(job_name) + f"/{build_number}/api/json"
-    return client.get_json(path, tree="artifacts[fileName,relativePath]")
-
-
-def wait_for_build(
-    client: JenkinsClient,
-    job_name: str,
-    number: int,
-    timeout: int = 600,
-    poll_interval: int = 2,
-) -> dict[str, Any]:
-    """Poll until a build completes or *timeout* is reached.
-
-    :param timeout: Maximum seconds to wait.
-    :param poll_interval: Seconds between status checks.
-    :returns: Final build dict.
-    :raises TimeoutError: if the build does not finish within *timeout*.
-    """
-    deadline = time.monotonic() + timeout
-    while time.monotonic() < deadline:
-        build = get_build(client, job_name, number)
-        if not build.get("building", False):
-            return build
-        time.sleep(poll_interval)
-    raise TimeoutError(
-        f"Build {job_name}#{number} did not complete within {timeout}s"
-    )

jcli/sdk/credential.py

@@ -1,143 +0,0 @@
-"""Jenkins Credential SDK.
- 
-Provides functions for managing Jenkins credentials via the REST API.
-Default store is ``system``, default domain is ``_`` (global domain).
- 
-API reference:
-  - List:   GET  /credentials/store/{store}/domain/{domain}/api/json
-  - Get:    GET  /credentials/store/{store}/domain/_/credential/{id}/api/json
-  - Create: POST /credentials/store/{store}/domain/{domain}/createCredentials
-  - Update: POST /credentials/store/{store}/domain/_/credential/{id}/updateCredentials
-  - Delete: POST /credentials/store/{store}/domain/{domain}/credential/{id}/doDelete
-"""
-
-from __future__ import annotations
-
-from typing import Any
-
-from jcli.sdk.client import JenkinsClient
-
-
-DEFAULT_STORE = "system"
-DEFAULT_DOMAIN = "_"
-
-
-def _build_base_path(store: str, domain: str) -> str:
-    """Build the base path for credential store/domain operations."""
-    return f"/credentials/store/{store}/domain/{domain}"
-
-
-def list_credentials(
-    client: JenkinsClient,
-    store: str = DEFAULT_STORE,
-    domain: str = DEFAULT_DOMAIN,
-    depth: int | None = None,
-) -> Any:
-    """List all credentials in a store/domain.
-
-    Args:
-        client: Jenkins API client.
-        store: Credential store ID (default: ``system``).
-        domain: Credential domain ID (default: ``_``).
-        depth: Optional API depth parameter for nested expansion.
-
-    Returns:
-        Parsed JSON response from Jenkins.
-    """
-    path = f"{_build_base_path(store, domain)}/api/json"
-    params: dict[str, Any] = {}
-    if depth is not None:
-        params["depth"] = str(depth)
-    return client.get_json(path, params=params)
-
-
-def get_credential(
-    client: JenkinsClient,
-    cred_id: str,
-    store: str = DEFAULT_STORE,
-) -> Any:
-    """Get details of a single credential.
-
-    Args:
-        client: Jenkins API client.
-        cred_id: Credential ID.
-        store: Credential store ID (default: ``system``).
-
-    Returns:
-        Parsed JSON response containing credential details.
-    """
-    path = (
-        f"{_build_base_path(store, DEFAULT_DOMAIN)}"
-        f"/credential/{cred_id}/api/json"
-    )
-    return client.get_json(path)
-
-
-def create_credential(
-    client: JenkinsClient,
-    xml_data: str | bytes,
-    store: str = DEFAULT_STORE,
-    domain: str = DEFAULT_DOMAIN,
-) -> Any:
-    """Create a new credential from XML config.
-
-    The XML must follow the Jenkins credentials XStream format for the
-    target credential type (e.g. ``UsernamePasswordCredentialsImpl``).
-
-    Args:
-        client: Jenkins API client.
-        xml_data: Credential XML config (str or bytes).
-        store: Credential store ID (default: ``system``).
-        domain: Credential domain ID (default: ``_``).
-
-    Returns:
-        ``requests.Response`` from the POST request.
-    """
-    path = f"{_build_base_path(store, domain)}/createCredentials"
-    return client.post_xml(path, xml_data)
-
-
-def update_credential(
-    client: JenkinsClient,
-    cred_id: str,
-    xml_data: str | bytes,
-    store: str = DEFAULT_STORE,
-) -> Any:
-    """Update an existing credential.
-
-    Args:
-        client: Jenkins API client.
-        cred_id: Credential ID to update.
-        xml_data: New credential XML config.
-        store: Credential store ID (default: ``system``).
-
-    Returns:
-        ``requests.Response`` from the POST request.
-    """
-    path = (
-        f"{_build_base_path(store, DEFAULT_DOMAIN)}"
-        f"/credential/{cred_id}/updateCredentials"
-    )
-    return client.post_xml(path, xml_data)
-
-
-def delete_credential(
-    client: JenkinsClient,
-    cred_id: str,
-    store: str = DEFAULT_STORE,
-) -> Any:
-    """Delete a credential.
-
-    Args:
-        client: Jenkins API client.
-        cred_id: Credential ID to delete.
-        store: Credential store ID (default: ``system``).
-
-    Returns:
-        ``requests.Response`` from the POST request.
-    """
-    path = (
-        f"{_build_base_path(store, DEFAULT_DOMAIN)}"
-        f"/credential/{cred_id}/doDelete"
-    )
-    return client.post_data(path, data={})

jcli/sdk/job.py

@@ -1,191 +0,0 @@
-"""Jenkins Job SDK — CRUD and lifecycle operations for Jenkins jobs."""
-
-from __future__ import annotations
-
-from typing import Any
-
-from jcli.sdk.client import JenkinsClient
-
-
-def list_jobs(client: JenkinsClient, depth: int = 0) -> list[dict[str, Any]]:
-    """List all jobs with name, url, and color.
-
-    Args:
-        client: Authenticated JenkinsClient instance.
-        depth: Recursion depth for folder jobs (0 = top-level only).
-
-    Returns:
-        List of job dicts with keys: name, url, color.
-    """
-    data = client.get_json("/api/json", tree="jobs[name,url,color]")
-    return data.get("jobs", [])
-
-
-def get_job(client: JenkinsClient, name: str) -> dict[str, Any]:
-    """Get full details for a specific job.
-
-    Args:
-        client: Authenticated JenkinsClient instance.
-        name: Job name (URL-encoding is handled by the client).
-
-    Returns:
-        Job details dict as returned by the Jenkins REST API.
-
-    Raises:
-        JenkinsNotFoundError: If the job does not exist.
-    """
-    return client.get_json(f"/job/{name}/api/json")
-
-
-def create_job(client: JenkinsClient, name: str, config_xml: str) -> None:
-    """Create a new job from an XML configuration string.
-
-    Args:
-        client: Authenticated JenkinsClient instance.
-        name: Name for the new job.
-        config_xml: Jenkins job config XML as a string.
-
-    Raises:
-        JenkinsAPIError: On creation failure (e.g. duplicate name, bad XML).
-    """
-    client.post_xml(f"/createItem?name={name}", config_xml)
-
-
-def delete_job(client: JenkinsClient, name: str) -> None:
-    """Delete a job.
-
-    Args:
-        client: Authenticated JenkinsClient instance.
-        name: Name of the job to delete.
-
-    Raises:
-        JenkinsNotFoundError: If the job does not exist.
-    """
-    client.post_data(f"/job/{name}/doDelete", data={})
-
-
-def copy_job(client: JenkinsClient, from_name: str, new_name: str) -> None:
-    """Copy an existing job to a new name.
-
-    Args:
-        client: Authenticated JenkinsClient instance.
-        from_name: Source job name.
-        new_name: Name for the copied job.
-
-    Raises:
-        JenkinsNotFoundError: If the source job does not exist.
-    """
-    client.post_data(
-        "/createItem",
-        data={"name": new_name, "mode": "copy", "from": from_name},
-    )
-
-
-def rename_job(
-    client: "JenkinsClient",
-    old_name: str,
-    new_name: str,
-) -> Any:
-    """Rename a job.
-
-    Args:
-        client: Jenkins API client.
-        old_name: Current job name.
-        new_name: New job name.
-
-    Returns:
-        Response from Jenkins (redirect on success).
-
-    Raises:
-        JenkinsNotFoundError: If the job does not exist.
-    """
-    path = f"/job/{old_name}/doRename"
-    return client.request("POST", path, params={"newName": new_name})
-
-
-def enable_job(client: JenkinsClient, name: str) -> None:
-    """Enable a disabled job.
-
-    Args:
-        client: Authenticated JenkinsClient instance.
-        name: Name of the job to enable.
-
-    Raises:
-        JenkinsNotFoundError: If the job does not exist.
-    """
-    client.post_data(f"/job/{name}/enable", data={})
-
-
-def disable_job(client: JenkinsClient, name: str) -> None:
-    """Disable a job.
-
-    Args:
-        client: Authenticated JenkinsClient instance.
-        name: Name of the job to disable.
-
-    Raises:
-        JenkinsNotFoundError: If the job does not exist.
-    """
-    client.post_data(f"/job/{name}/disable", data={})
-
-
-def update_job_config(
-    client: JenkinsClient,
-    name: str,
-    config_xml: str,
-) -> Any:
-    """Update a job's configuration.
-
-    Args:
-        client: Jenkins API client.
-        name: Job name.
-        config_xml: New XML configuration.
-
-    Returns:
-        Response from Jenkins.
-    """
-    return client.post_xml(f"/job/{name}/config.xml", config_xml)
-
-
-def get_job_config(client: JenkinsClient, name: str) -> str:
-    """Retrieve the XML configuration for a job.
-
-    Args:
-        client: Authenticated JenkinsClient instance.
-        name: Name of the job.
-
-    Returns:
-        Job configuration as an XML string.
-
-    Raises:
-        JenkinsNotFoundError: If the job does not exist.
-    """
-    resp = client.request("GET", f"/job/{name}/config.xml")
-    return resp.text
-
-
-def create_folder(client: JenkinsClient, name: str) -> Any:
-    """Create a Jenkins folder.
-
-    Args:
-        client: Jenkins API client.
-        name: Folder name.
-
-    Returns:
-        Response from Jenkins.
-    """
-    path = f"/createItem?name={name}&mode=com.cloudbees.hudson.plugins.folder.Folder"
-    return client.request("POST", path)
-
-
-def delete_folder(client: JenkinsClient, name: str) -> Any:
-    """Delete a Jenkins folder and all its contents.
-
-    Args:
-        client: Jenkins API client.
-        name: Folder name.
-
-    Returns:
-        Response from Jenkins.
-    """
-    return client.request("POST", f"/job/{name}/doDelete")