pinexq-cli 0.1.5__py3-none-any.whl

pinexq/cli/__main__.py

@@ -0,0 +1,28 @@
+from typing import Optional
+import signal
+import logging
+
+from dotenv import load_dotenv
+
+from pinexq.cli.cmd.cli import pinexq
+
+log = logging.getLogger(__name__)
+
+load_dotenv()
+
+def signal_handler(_sig, _frame):
+    print('Aborting')
+    exit(0)
+
+def main(argv: Optional[list[str]] = None) -> None:
+    signal.signal(signal.SIGINT, signal_handler)
+    # Delegate to Typer app
+    # If argv is None, Typer uses sys.argv automatically
+    if argv is None:
+        pinexq(prog_name="pinexq")
+    else:
+        pinexq(args=argv, prog_name="pinexq")
+
+
+if __name__ == "__main__":
+    main()

pinexq/cli/cmd/cli.py

@@ -0,0 +1,122 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Optional
+import importlib.metadata
+
+import typer.rich_utils  # important: import the module, not individual names
+
+from .deploy import deploy as deploy_impl, DeployOptions
+from .register import register as register_impl, RegisterOptions
+from .generate import generate_app
+from .initialization import init_project
+from ..docker_tools.client import load_docker_client
+from ..pinexq_tools.project import get_project_meta
+
+
+@dataclass
+class CLIContext:
+    pinexq_endpoint: Optional[str] = None
+    verbose: bool = False
+
+
+typer.rich_utils.STYLE_METAVAR = 'bold dark_orange'
+typer.rich_utils.STYLE_USAGE = 'dark_orange'
+typer.rich_utils.STYLE_OPTION_ENVVAR = 'dim dark_orange'
+app = typer.Typer(
+    name="pinexq",
+    invoke_without_command=True,
+    add_completion=False,
+    no_args_is_help=True,
+    suggest_commands=True,
+    rich_markup_mode="rich",
+)
+
+
+def version_callback(value: bool):
+    if value:
+        try:
+            # Replace "your-package-name" with the name in your pyproject.toml
+            version = importlib.metadata.version("pinexq-cli")
+            print(f"CLI Version: {version}")
+        except importlib.metadata.PackageNotFoundError:
+            print("Version not found (package might not be installed)")
+        raise typer.Exit()
+
+
+@app.callback()
+def _pinexq_callback(
+        ctx: typer.Context,
+        endpoint: Optional[str] = typer.Option(None, "--endpoint", envvar="PINEXQ_ENDPOINT", help="Pinexq endpoint"),
+        version: bool = typer.Option(False, "--version", help="Prints the version", callback=version_callback),
+        verbose: bool = typer.Option(False, "--verbose", help="Debug output"),
+):
+    ctx.obj = CLIContext(pinexq_endpoint=endpoint, verbose=verbose)
+
+
+@app.command(name="deploy", rich_help_panel="Deploy functions to Pinexq")
+def deploy(
+        dockerfile: str = typer.Option("./Dockerfile", "-D", "--dockerfile", show_default=True),
+        context_dir: str = typer.Option("./", "--context-dir", show_default=True),
+        api_key: str = typer.Option(None, "--api-key", envvar="PINEXQ_API_KEY", help="Pinexq API key"),
+        functions: list[str] = typer.Option(None, "-f", "--function", help="Select functions to deploy"),
+        secrets: list[str] = typer.Option(None, '--secret', help="Secrets to be passed to the docker build"),
+):
+    """
+    Deploy functions to [dark_orange]Pinexq[/dark_orange]. This builds and pushes an OCI-compatible image to Pinexq and registers the function with the API.
+    """
+    # TODO: use overrides for project_meta
+    docker_client = load_docker_client()
+    project_meta = get_project_meta()
+    deploy_impl(DeployOptions(
+        dockerfile=dockerfile,
+        context_dir=context_dir,
+        api_key=api_key or "",
+        functions=list(functions or []),
+        secrets=list(secrets or []),
+    ), docker_client, project_meta)
+
+
+@app.command(name="init", help="Initialize a pinexq project")
+def init(
+        path: str = typer.Argument("./"),
+        template: str = typer.Option("gh:data-cybernetics/pinexq-project-starter.git", "--template", show_default=True),
+        version: str = typer.Option("latest", "--template-version", show_default=True),
+        project_name: str = typer.Option(None, "--project-name", help="Project name"),
+        pinexq_endpoint: str = typer.Option(None, "--pinexq-endpoint", help="Pinexq endpoint"),
+):
+    init_project(
+        path,
+        template,
+        version,
+        project_name=project_name,
+        pinexq_endpoint=pinexq_endpoint
+    )
+
+@app.command(name="register", help="Register functions in Pinexq")
+def register(
+        dockerfile: str = typer.Option("./Dockerfile", "-D", "--dockerfile", show_default=True),
+        context_dir: str = typer.Option("./", "--context-dir", show_default=True),
+        api_key: str = typer.Option(None, "--api-key", envvar="PINEXQ_API_KEY", help="Pinexq API key"),
+        functions: list[str] = typer.Option(None, "-f", "--function", help="Select functions to deploy"),
+        secrets: list[str] = typer.Option(None, '--secret', help="Secrets to be passed to the docker build"),
+):
+    docker_client = load_docker_client()
+    project_meta = get_project_meta()
+    register_impl(RegisterOptions(
+        dockerfile=dockerfile,
+        context_dir=context_dir,
+        api_key=api_key or "",
+        functions=list(functions or []),
+        secrets=list(secrets or []),
+    ), docker_client, project_meta)
+
+# Register sub-apps
+app.add_typer(generate_app, name="generate")
+
+# Backwards-compatibility for type hints imported in other modules
+# Export name `CLI` to represent the root context type
+CLI = CLIContext
+
+# For compatibility with the existing import name
+pinexq = app

pinexq/cli/cmd/deploy.py

@@ -0,0 +1,98 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+
+from pinexq_client.job_management import enter_jma, EntryPointHco
+from pinexq_client.job_management.model import ConfigureDeploymentParameters, \
+    ScalingConfiguration, ScalingBehaviours, AssignCodeHashParameters, DeploymentStates
+
+from pinexq.cli.cmd.register import register_processing_step
+from pinexq.cli.docker_tools.client import ContainerClient
+from pinexq.cli.pinexq_tools.client import get_client
+from pinexq.cli.pinexq_tools.info import get_info
+from pinexq.cli.pinexq_tools.manifest import generate_manifests, BuildOptions
+from pinexq.cli.pinexq_tools.project import PinexqProjectConfig
+from pinexq.cli.utils.console import console, err_console
+from pinexq.cli.utils.const import PINEXQ_PREFIX as PREFIX, PINEXQ_ERROR_PREFIX as ERROR_PREFIX
+from pinexq.cli.utils.uv_utils import is_uv_lockfile_up_to_date
+
+
+@dataclass
+class DeployOptions:
+    dockerfile: str = "./Dockerfile"
+    context_dir: str = "./"
+    api_key: str = ""
+    functions: list[str] = field(default_factory=list)
+    secrets: list[str] = field(default_factory=list)
+
+
+def deploy(deploy_command: DeployOptions, container_client: ContainerClient, config: PinexqProjectConfig):
+    try:
+        pinexq_client = get_client(config.project.endpoint, deploy_command.api_key)
+        info = get_info(pinexq_client)
+        if 'grant:codeContributor' not in info.user_grants and 'role:admin' not in info.user_grants:
+            err_console.print(
+                f'{ERROR_PREFIX} You do not have permission to deploy functions. Please ask your administrator or support to grant you the permission.')
+            exit(1)
+        if not is_uv_lockfile_up_to_date():
+            err_console.print(f'{ERROR_PREFIX} uv lockfile is not up to date. Please run `uv lock` to update it.')
+            exit(1)
+
+        manifests, functions = generate_manifests(container_client, deploy_command.functions, BuildOptions(
+            dockerfile=deploy_command.dockerfile,
+            context_dir=deploy_command.context_dir,
+            tag=f'{config.project.name}:{config.project.version}',
+            secrets=deploy_command.secrets,
+            entrypoint=config.project.entrypoint
+        ))
+        if not manifests:
+            err_console.print(f'{ERROR_PREFIX} Failed to list functions in procon.')
+        console.print(f'{PREFIX} Deploying following functions: {functions}')
+
+        # This will build the base image again for the destination architecture amd64
+        base_image = container_client.build_base_image(deploy_command.context_dir, deploy_command.dockerfile,
+                                                       f'{config.project.name}:{config.project.version}',
+                                                       secrets=deploy_command.secrets)
+        if not base_image:
+            console.print(f'{ERROR_PREFIX} Failed to build base image.')
+            exit(1)
+
+        # Start registering the PS
+        entrypoint: EntryPointHco = enter_jma(pinexq_client)
+        console.print(f'{PREFIX} Registering function{"s" if len(functions) > 1 else ""} at {config.project.endpoint}')
+        for function_name in functions:
+            version = manifests[function_name]['version']
+            console.print(f'{PREFIX} start deploying function {function_name}:{version}')
+            processing_step = register_processing_step(entrypoint, function_name, version, manifests[function_name])
+
+            if processing_step.deployment_state != DeploymentStates.undefined or processing_step.deployment_state != DeploymentStates.not_deployed:
+                console.print(f'{PREFIX} Processing step for function {function_name}:{version} is already deployed. Skipping deployment.')
+                continue
+            if processing_step._entity.properties.code_hash is not None:
+                console.print(f'{PREFIX} Processing step for function {function_name}:{version} is already registered with an code artifact. Skipping deployment.')
+                continue
+            else:
+                # Push image to registry
+                if not container_client.tag_base_image_as_function(base_image, info, function_name, version):
+                    exit(1)
+                digest = container_client.push_function_image(info, function_name, version)
+                if not digest:
+                    console.print(f'{ERROR_PREFIX} Failed to push function image for {function_name}:{version}')
+                    exit(1)
+                deployment = config.get_function_deployment(function_name)
+                processing_step.self_link.navigate().assign_code_hash_action.execute(
+                    AssignCodeHashParameters(CodeHash=digest))
+                processing_step.self_link.navigate().configure_deployment_action.execute(
+                    ConfigureDeploymentParameters(
+                        ResourcePreset=deployment.resource_preset,
+                        Entrypoint=config.project.entrypoint,
+                        Scaling=ScalingConfiguration(
+                            MaxReplicas=deployment.max_replicas,
+                            Behaviour=ScalingBehaviours.balanced
+                        ),
+                    )
+                )
+
+    except Exception as e:
+        err_console.print(f'{ERROR_PREFIX} Error: {e}')
+        exit(1)

pinexq/cli/cmd/generate.py

@@ -0,0 +1,60 @@
+import typer
+from copier import run_copy, CopierAnswersInterrupt
+from copier.errors import CopierError
+from rich.console import Console
+
+generate_app = typer.Typer(name="generate", no_args_is_help=True)
+
+# REUSABLE OPTIONS
+Template = typer.Option("gh:data-cybernetics/pinexq-project-starter.git", "--template", show_default=True)
+Version = typer.Option("latest", "--template-version", show_default=True)
+Path = typer.Option("./", "--path", show_default=True)
+
+err_console = Console(stderr=True)
+
+
+@generate_app.command(name="project-toml", help="Generate project.toml")
+def generate_project_toml(
+        template: str = Template,
+        version: str = Version,
+        path: str = Path,
+):
+    data = {'python_versions': ['3.14'], 'default_python_version': '3.14'}
+    generate_project_file(path, template, version, target_files=["pinexq.toml"], data=data)
+
+
+@generate_app.command(name="dockerfile", help="Generate Dockerfile")
+def generate_dockerfile(
+        template: str = Template,
+        version: str = Version,
+        path: str = Path,
+        python_version: str = typer.Option(None, "--python-version", help="Python version to use in Dockerfile")
+):
+    allowed_versions = ['3.14', '3.13', '3.12', '3.11']
+    data = {'project_name': 'dummy', 'pinexq_endpoint': 'dummy', 'python_versions': allowed_versions}
+    if python_version:
+        if python_version not in allowed_versions:
+            raise typer.BadParameter(f'Provided version ({python_version}) is not allowed. Allowed versions are: {allowed_versions}')
+        data['default_python_version'] = python_version
+    generate_project_file(
+        path,
+        template,
+        version,
+        target_files=["Dockerfile", ".dockerignore"],
+        data=data
+    )
+
+
+def generate_project_file(path: str, template: str, template_version: str, target_files: list[str], data: dict = None):
+    try:
+        run_copy(
+            template,
+            path,
+            vcs_ref=template_version if template_version != "latest" else None,
+            exclude=["*", *[f"!{target_files}" for target_files in target_files]],
+            data=data
+        )
+    except CopierAnswersInterrupt:
+        err_console.print("Project generation aborted")
+    except CopierError as e:
+        err_console.print(f"Error during project generation: {e}")

pinexq/cli/cmd/initialization.py

@@ -0,0 +1,24 @@
+from __future__ import annotations
+from rich.console import Console
+from copier import run_copy, CopierAnswersInterrupt
+from copier.errors import CopierError
+
+err_console = Console(stderr=True)
+console = Console(highlight=False)
+
+
+def init_project(path: str, template: str, version: str, project_name: str | None = None, pinexq_endpoint: str | None = None) -> None:
+    data = {}
+    if project_name:
+        data["project_name"] = project_name
+    if pinexq_endpoint:
+        data["pinexq_endpoint"] = pinexq_endpoint
+    try:
+        run_copy(template,
+                 path,
+                 vcs_ref=version if version != "latest" else None,
+                 data=data)
+    except CopierAnswersInterrupt:
+        console.print("Project generation aborted")
+    except CopierError as e:
+        err_console.print(f"Error during project generation: {e}")

pinexq/cli/cmd/register.py

@@ -0,0 +1,91 @@
+from dataclasses import dataclass, field
+
+from pinexq_client.core import ApiException
+from pinexq_client.core.hco.upload_action_hco import UploadParameters
+from pinexq_client.job_management.model import ProcessingStepQueryParameters, ProcessingStepFilterParameter, CreateProcessingStepParameters, Pagination, FunctionNameMatchTypes
+from rich.console import Console
+
+from pinexq_client.job_management import enter_jma, EntryPointHco, ProcessingStepsRootHco
+
+from pinexq.cli.pinexq_tools.info import get_info
+from pinexq.cli.pinexq_tools.manifest import generate_manifests, BuildOptions
+from pinexq.cli.utils.const import PINEXQ_PREFIX as PREFIX, PINEXQ_ERROR_PREFIX as ERROR_PREFIX
+from pinexq.cli.docker_tools.client import ContainerClient
+from pinexq.cli.pinexq_tools.client import get_client
+from pinexq.cli.pinexq_tools.project import PinexqProjectConfig
+from pinexq.cli.utils.uv_utils import is_uv_lockfile_up_to_date
+
+err_console = Console(stderr=True)
+console = Console(highlight=False)
+
+
+@dataclass
+class RegisterOptions:
+    dockerfile: str = "./Dockerfile"
+    context_dir: str = "./"
+    api_key: str = ""
+    functions: list[str] = field(default_factory=list)
+    secrets: list[str] = field(default_factory=list)
+
+
+def register(options: RegisterOptions, container_client: ContainerClient, config: PinexqProjectConfig):
+    try:
+        pinexq_client = get_client(config.project.endpoint, options.api_key)
+        info = get_info(pinexq_client)
+        if 'grant:codeContributor' not in info.user_grants and 'role:admin' not in info.user_grants:
+            err_console.print(
+                f'{ERROR_PREFIX} You do not have permission to register or deploy functions. Please ask your administrator or support to grant you the permission.')
+            exit(1)
+        if not is_uv_lockfile_up_to_date():
+            err_console.print(f'{ERROR_PREFIX} uv lockfile is not up to date. Please run `uv lock` to update it.')
+            exit(1)
+
+        manifests, functions = generate_manifests(container_client, options.functions, BuildOptions(
+            dockerfile=options.dockerfile,
+            context_dir=options.context_dir,
+            tag=f'{config.project.name}:{config.project.version}',
+            secrets=options.secrets,
+            entrypoint=config.project.entrypoint
+        ))
+        if not manifests:
+            err_console.print(f'{ERROR_PREFIX} Failed to list functions in procon.')
+        console.print(f'{PREFIX} Register following functions: {functions}')
+
+        # Start registering the PS
+        entrypoint: EntryPointHco = enter_jma(pinexq_client)
+        console.print(f'{PREFIX} Registering function at {config.project.endpoint}')
+        for function_name in functions:
+            version = manifests[function_name]['version']
+            console.print(f'{PREFIX} Deploying function {function_name}:{version}')
+            register_processing_step(entrypoint, function_name, version, manifests[function_name])
+    except Exception as e:
+        err_console.print(f'{ERROR_PREFIX} Error: {e}')
+        exit(1)
+
+
+def register_processing_step(entrypoint: EntryPointHco, function_name: str, version: str, manifest: dict[str, dict]):
+    processing_step_root: ProcessingStepsRootHco = entrypoint.processing_step_root_link.navigate()
+    ps_filter = ProcessingStepFilterParameter(FunctionName=function_name, Version=version, ShowDeprecated=False, FunctionNameMatchType=FunctionNameMatchTypes.match_exact)
+    existing_steps = processing_step_root.query_action.execute(ProcessingStepQueryParameters(Filter=ps_filter, IncludeRemainingTags=False, Pagination=Pagination(PageSize=1, PageOffset=None)))
+    if existing_steps.current_entities_count == 0:
+        console.print(f'{PREFIX} Processing step for function {function_name}:{version} does not exist. Creating new one.')
+        try:
+            params = CreateProcessingStepParameters(FunctionName=function_name, Title=function_name,
+                                                    Version=version)
+            processing_step = processing_step_root.register_new_action.execute(params)
+            processing_step.upload_configuration_action.execute(
+                UploadParameters(filename='UploadFile', mediatype='application/json',
+                                 json=manifest))
+        except ApiException as e:
+            if e.problem_details.detail == 'A processing step with the same function name already exists.':
+                console.print(
+                    f'{PREFIX} Processing step for function {function_name}:{version} in version [bold dark_orange]{version}[/bold dark_orange] already exists. Skipping deployment.')
+                exit(0)
+            else:
+                err_console.print(
+                    f'{ERROR_PREFIX} Error registering processing step for function {function_name}:{version}:')
+                exit(1)
+    else:
+        console.print(
+            f'{PREFIX} Processing step for function {function_name}:{version} in version [bold dark_orange]{version}[/bold dark_orange] already exists.')
+        return existing_steps.processing_steps[0]

pinexq/cli/docker_tools/client.py

@@ -0,0 +1,229 @@
+import json
+import os
+import subprocess
+from typing import Optional, Union
+
+import docker
+from docker import DockerClient
+from docker.errors import APIError
+from docker.models.images import Image
+from rich.progress import Progress, BarColumn, TextColumn, TaskProgressColumn, DownloadColumn, TransferSpeedColumn, \
+    TaskID
+from rich.console import Console
+
+from pinexq.cli.pinexq_tools.info import Info
+from pinexq.cli.utils.const import DOCKER_PREFIX as PREFIX
+
+err_console = Console(stderr=True)
+console = Console(highlight=False)
+
+
+def print_stream_logs(logs):
+    try:
+        for chunk in logs or []:
+            line = chunk.get('stream')
+            if line and line != '\n':
+                console.print(f"{line.rstrip()}")
+    except Exception:
+        pass
+
+
+def print_push_logs(logs):
+    """Render docker push logs using rich progress bars per layer id."""
+    try:
+        layer_tasks: dict[str, TaskID] = {}
+        finished_layers: set[str] = set()
+
+        progress = Progress(
+            TextColumn("{task.description}"),
+            BarColumn(),
+            TaskProgressColumn(),
+            DownloadColumn(),
+            TransferSpeedColumn(),
+            transient=True,
+        )
+
+        with progress:
+            for chunk in logs or []:
+                status = chunk.get('status')
+                layer_id = chunk.get('id')
+                detail = chunk.get('progressDetail') or {}
+                total = detail.get('total')
+                current = detail.get('current')
+
+                # If no layer id, print general status when not mid-push UI
+                if not layer_id:
+                    if status:
+                        print(f"{status.rstrip()}")
+                    continue
+
+                # Ensure a task exists for this layer
+                if layer_id not in layer_tasks:
+                    desc = f"Waiting {layer_id}"
+                    task_id = progress.add_task(desc, total=total if total else 1, completed=0)
+                    layer_tasks[layer_id] = task_id
+
+                task_id = layer_tasks[layer_id]
+
+                if status == 'Waiting':
+                    progress.update(task_id, description=f"Waiting {layer_id}")
+                    continue
+
+                if status == 'Pushing':
+                    if total and current is not None:
+                        progress.update(task_id, total=total, completed=current, description=f"Pushing {layer_id}")
+                    elif current is not None:
+                        # Unknown total; treat as indeterminate with growing total
+                        progress.update(task_id, total=None, completed=current, description=f"Pushing {layer_id}")
+                    else:
+                        progress.update(task_id, description=f"Pushing {layer_id}")
+                    continue
+
+                if status == 'Pushed':
+                    if total:
+                        progress.update(task_id, total=total, completed=total, description=f"Pushed  {layer_id}")
+                    else:
+                        progress.update(task_id, total=1, completed=1, description=f"Pushed  {layer_id}")
+                    finished_layers.add(layer_id)
+                    continue
+
+                if status == 'Layer already exists' or (isinstance(status, str) and status.startswith('Mounted from')):
+                    progress.update(task_id, total=1, completed=1, description=f"Exists  {layer_id}")
+                    finished_layers.add(layer_id)
+                    continue
+
+                # Fallback update to show any other status
+                if status:
+                    progress.update(task_id, description=f"{status} {layer_id}")
+    except Exception as e:
+        err_console.print(e)
+        pass
+
+
+class ContainerClient:
+    def __init__(self, client: DockerClient):
+        self.client = client
+
+    def pre_build_image(self, context_dir: str, dockerfile: str, tag: str, verbose=True, secrets=None) -> \
+            Optional[Image]:
+        if secrets is None:
+            secrets = []
+        secrets_arg = [arg for secret in secrets for arg in ('--secret', secret)]
+        command = ['docker', 'build', '--progress', 'plain', '-t', tag, '-f', dockerfile, *secrets_arg, context_dir]
+        return self.build_image(command, tag, verbose)
+
+    def build_base_image(self, context_dir: str, dockerfile: str, tag: str, verbose=True, secrets=None) -> Optional[
+        Image]:
+        # We need to directly build the docker image since buildkit is not supported by docker-py
+        # https://github.com/docker/docker-py/issues/2230
+        if secrets is None:
+            secrets = []
+        secrets_arg = [arg for secret in secrets for arg in ('--secret', secret)]
+        command = ['docker', 'build', '--progress', 'plain',
+                   '--platform', 'linux/amd64',
+                   '-t', tag, '-f', dockerfile, *secrets_arg, context_dir]
+        return self.build_image(command, tag, verbose)
+
+    def build_image(self, command: list[str], tag: str, verbose=True) -> Optional[Image]:
+        console.print(f"{PREFIX} Running docker build command: {' '.join(command)}")
+        with subprocess.Popen(
+                command,
+                stdout=subprocess.PIPE,
+                stderr=subprocess.STDOUT,
+                text=True,
+                bufsize=1,
+                universal_newlines=True,
+                env=os.environ,
+        ) as process:
+            import time
+            message = f"{PREFIX} [bold dodger_blue1]Waiting for docker...[/]"
+            collected = [message]
+            with console.status(message, spinner="dots") as status:
+                def verbose_log():
+                    for line in process.stdout:
+                        collected.append(line.strip())
+                        status.update('\n'.join(collected))
+                        time.sleep(0.01)
+
+                def log():
+                    for line in process.stdout:
+                        status.update(f'{message}: {line.strip()}')
+                        time.sleep(0.01)
+
+                verbose_log() if verbose else log()
+            if verbose:
+                console.print('\n'.join(collected))
+        return_code = process.poll()
+        if return_code == 0:
+            return self.client.images.get(tag)
+        else:
+            err_console.print(f"{PREFIX} Docker build failed with return code {return_code}")
+            return None
+
+    @staticmethod
+    def tag_base_image_as_function(image: Image, info: Info, function_name: str, function_version: str) -> bool:
+        dist_tag = f"{info.registry_endpoint}/{info.get_context_id()}/{function_name}:{function_version}"
+        try:
+            image.tag(repository=dist_tag)
+            console.print(f"{PREFIX} Tagged image {image.id} as {dist_tag}")
+            return True
+        except APIError as e:
+            err_console.print(f"{PREFIX} Docker API error: {e}")
+            return False
+
+    def push_function_image(self, info: Info, function_name: str, function_version: str) -> Union[str, None]:
+        repo = f"{info.registry_endpoint}/{info.get_context_id()}/{function_name}"
+        try:
+            push_logs = self.client.images.push(repo, tag=function_version, auth_config=info.get_docker_auth(),
+                                                stream=True, decode=True)
+            print_push_logs(push_logs)
+            console.print(f"{PREFIX} Pushed function image {repo}:{function_version}")
+            image = self.client.images.get(f'{repo}:{function_version}')
+            return self.get_image_digest(image)
+        except APIError as e:
+            err_console.print(f"{PREFIX} Docker API error: {e}")
+            return None
+
+    def run_function_list(self, image: Image, entrypoint: str = 'main.py') -> list[str] | None:
+        try:
+            output_bytes = self.client.containers.run(image.id, f'{entrypoint} list -j', detach=False, remove=True)
+            output_str = output_bytes.decode("utf-8").strip()
+            return json.loads(output_str)
+        except docker.errors.ContainerError as e:
+            err_console.print(f"Container exited with non-zero exit code: {e.exit_status}")
+            err_console.print(f"Stderr: {e.stderr}")
+        except docker.errors.ImageNotFound:
+            err_console.print("Image not found locally.")
+        except docker.errors.APIError as e:
+            err_console.print(f"Docker API Error: {e}")
+
+    def run_manifest(self, image: Image, function: str, entrypoint: str = 'main.py') -> dict | None:
+        try:
+            output_bytes = self.client.containers.run(image.id, f'{entrypoint} signature --function {function} -j',
+                                                      detach=False, remove=True)
+            output_str = output_bytes.decode("utf-8").strip()
+            return json.loads(output_str)
+        except docker.errors.ContainerError as e:
+            err_console.print(f"Container exited with non-zero exit code: {e.exit_status}")
+            err_console.print(f"Stderr: {e.stderr}")
+        except docker.errors.ImageNotFound:
+            err_console.print("Image not found locally.")
+        except docker.errors.APIError as e:
+            err_console.print(f"Docker API Error: {e}")
+
+    @staticmethod
+    def get_image_digest(image: Image) -> str | None:
+        # Hack to get the correct image digest for docker v2 manifests version
+        repo_digests = image.attrs.get('RepoDigests')
+        if not repo_digests:
+            return image.id
+        return repo_digests[0].split('@')[-1] if len(repo_digests) > 0 else image.id
+
+
+def load_docker_client() -> ContainerClient:
+    try:
+        client = docker.from_env()
+        return ContainerClient(client)
+    except Exception as e:
+        err_console.print(f'cannot connect to docker socket: {e}')
+        exit(1)

pinexq/cli/pinexq_tools/client.py

@@ -0,0 +1,8 @@
+from httpx import Client
+
+
+def get_client(endpoint: str, api_key: str):
+    if api_key is None or api_key == "":
+        raise Exception("PINEXQ_API_KEY is required. Provide it by the environment variable `PINEXQ_API_KEY` globally or in .env or using --api-key flag.")
+    pinexq_endpoint = f'https://{endpoint.replace("https://", "").replace("http://", "")}'
+    return Client(base_url=pinexq_endpoint, headers={'x-api-key': api_key})

pinexq/cli/pinexq_tools/info.py

@@ -0,0 +1,37 @@
+from typing import Optional
+
+from httpx import Client
+from pinexq_client.job_management import EntryPointHco, enter_jma
+from pydantic import BaseModel
+
+
+class Info(BaseModel):
+    user_id: str
+    org_id: Optional[str] = None
+    user_grants: list[str]
+    registry_endpoint: str
+    api_key: str
+
+    def get_context_id(self) -> str:
+        if not self.org_id:
+            return self.user_id
+        else:
+            return self.org_id
+
+    def get_docker_auth(self):
+        return {
+            "username": self.user_id,
+            "password": self.api_key,
+        }
+
+
+def get_info(client: Client) -> Info:
+    entrypoint: EntryPointHco = enter_jma(client)
+    info = entrypoint.info_link.navigate()
+    return Info(
+        user_id=info.current_user.user_id.__str__(),
+        org_id=info.organization_id,
+        user_grants=info.current_user.user_grants,
+        registry_endpoint=str(info.deployment_registry_endpoint.get_url()),
+        api_key=client.headers.get("x-api-key")
+    )

pinexq/cli/pinexq_tools/manifest.py

@@ -0,0 +1,55 @@
+from dataclasses import dataclass
+import json
+import os
+from pathlib import Path
+from typing import Tuple
+
+from docker.models.images import Image
+
+from pinexq.cli.docker_tools.client import ContainerClient
+from pinexq.cli.utils.console import console, err_console
+from pinexq.cli.utils.const import PINEXQ_PREFIX as PREFIX, PINEXQ_ERROR_PREFIX as ERROR_PREFIX
+
+
+def generate_manifest_signature(container_client: ContainerClient, base_image: Image, function_name: str,
+                                entrypoint: str) -> dict:
+    return container_client.run_manifest(base_image, function_name, entrypoint=entrypoint)
+
+
+@dataclass
+class BuildOptions:
+    dockerfile: str
+    context_dir: str
+    secrets: list[str]
+    tag: str
+    entrypoint: str
+
+
+def generate_manifests(container_client: ContainerClient, functions: list[str], build_options: BuildOptions) -> Tuple[dict, list]:
+    # Generate manifests
+    # We are building the image for the current execution context to generate manifests
+    # This will build for the local architecture to make sure the manifest generation can be executed locally
+    base_image = container_client.pre_build_image(build_options.context_dir, build_options.dockerfile,
+                                                  build_options.tag,
+                                                  secrets=build_options.secrets)
+    if not base_image:
+        console.print(f'{ERROR_PREFIX} Failed to build base image.')
+        exit(1)
+    container_functions = container_client.run_function_list(base_image, entrypoint=build_options.entrypoint)
+    if not container_functions:
+        err_console.print(f'{ERROR_PREFIX} Failed to list functions in procon.')
+    console.print(f'{PREFIX} Found following functions in container: {container_functions}')
+    if len(functions) == 0:
+        functions = container_functions
+    else:
+        console.print(f'{PREFIX} Functions specified in command line: {functions}')
+        functions = [f for f in container_functions if f in functions]
+    manifests = {}
+    for function_name in functions:
+        signature = generate_manifest_signature(container_client, base_image, function_name, build_options.entrypoint)
+        manifests[function_name] = signature
+        os.makedirs('.manifests', exist_ok=True)
+        manifest_path = Path('.manifests') / f"{signature['function_name']}.json"
+        with open(manifest_path, 'w') as f:
+            json.dump(signature, f, indent=2)
+    return manifests, functions

pinexq/cli/pinexq_tools/project.py

@@ -0,0 +1,87 @@
+from typing import Tuple, Union
+import click
+import tomli
+from pinexq_client.job_management.model import DeploymentResourcePresets
+from pydantic import BaseModel, Field, field_validator
+
+from pinexq.cli.utils.const import PINEXQ_ERROR_PREFIX as ERROR_PREFIX
+
+
+class PinexqDeploymentSetting(BaseModel):
+    resource_preset: DeploymentResourcePresets
+    max_replicas: int
+
+
+class PinexqProjectDetails(BaseModel):
+    name: str = Field(None, alias="name")
+    endpoint: str = Field(None, alias="pinexq_endpoint")
+    entrypoint: str = Field('main.py')
+    version: str = Field(None)
+
+    @field_validator('entrypoint')
+    @classmethod
+    def validate_entrypoint(cls, v: str) -> str:
+        if not v.endswith(('.py', '.pyc')):
+            raise ValueError("entrypoint must have a python extension")
+        return v
+
+
+class PinexqProjectConfig(BaseModel):
+    # read from pinexq.toml
+    project: PinexqProjectDetails = Field(None)
+    deployment: PinexqDeploymentSetting = Field(None)
+    functions: dict[str, PinexqDeploymentSetting] = Field({}, alias="function")
+
+    # read from pyproject.toml
+
+    def get_function_deployment(self, function_name: str) -> PinexqDeploymentSetting:
+        function_config = self.functions.get(function_name)
+        resource_preset = function_config.resource_preset if function_config else self.deployment.resource_preset
+        max_replicas = function_config.max_replicas if function_config else self.deployment.max_replicas
+        return PinexqDeploymentSetting(resource_preset=resource_preset, max_replicas=max_replicas)
+
+
+def get_project_meta() -> PinexqProjectConfig:
+    [py_project_name, version] = _read_pyproject_toml()
+    ctx = click.get_current_context()
+    try:
+        pinexq_config = _read_pinexq_toml()
+        project_override = {}
+        if ctx.obj.pinexq_endpoint:
+            project_override = {'pinexq_endpoint': ctx.obj.pinexq_endpoint}
+        project_config = {**{'version': version, 'name': py_project_name}, **pinexq_config['project'], **project_override}
+        config = PinexqProjectConfig(**{**pinexq_config, **{'project': project_config}})
+    except ValueError as e:
+        print(f'{ERROR_PREFIX} Error reading pinexq.toml: {str(e)}')
+        exit(1)
+    return config
+
+
+def _read_pinexq_toml() -> dict[str, Union[str, int]]:
+    try:
+        with open("pinexq.toml", "rb") as f:
+            toml_dict = tomli.load(f)
+            return toml_dict
+    except FileNotFoundError:
+        print(f'{ERROR_PREFIX} pinexq.toml file not found in current directory')
+        exit(1)
+    except Exception as e:
+        print(f'{ERROR_PREFIX} Error reading pinexq.toml: {str(e)}')
+        exit(1)
+
+
+def _read_pyproject_toml() -> Tuple[str, str]:
+    try:
+        with open("pyproject.toml", "rb") as f:
+            toml_dict = tomli.load(f)
+
+        project_name = toml_dict.get("project", {}).get("name", "")
+        version = toml_dict.get("project", {}).get("version", "0.0.0")
+
+        return project_name, version
+    except FileNotFoundError:
+        print(f'{ERROR_PREFIX} pyproject.toml file not found in current directory')
+        exit(1)
+    except Exception as e:
+        print(f'{ERROR_PREFIX} Error reading pyproject.toml: {str(e)}')
+        exit(1)

pinexq/cli/utils/console.py

@@ -0,0 +1,5 @@
+from rich.console import Console
+
+err_console = Console(stderr=True)
+console = Console(highlight=False)
+

pinexq/cli/utils/const.py

@@ -0,0 +1,4 @@
+PINEXQ_PREFIX = '🌲 [bold dark_orange]pinexq:[/bold dark_orange]'
+PINEXQ_ERROR_PREFIX = '🚨 [bold red]pinexq:[/bold red]'
+DOCKER_PREFIX = '🐋 [bold dodger_blue1]docker:[/bold dodger_blue1]'
+

pinexq/cli/utils/uv_utils.py

@@ -0,0 +1,14 @@
+import subprocess
+
+
+def is_uv_lockfile_up_to_date() -> bool:
+    result = subprocess.run(
+        ['uv', 'lock', '--check'],
+        cwd='.',
+        stdout=subprocess.PIPE,
+        stderr=subprocess.PIPE,
+        text=True,
+    )
+    return result.returncode == 0
+
+

pinexq_cli-0.1.5.dist-info/METADATA

@@ -0,0 +1,34 @@
+Metadata-Version: 2.3
+Name: pinexq-cli
+Version: 0.1.5
+Summary: pinexq command-line interface
+Author: Sebastian Höfer, Sebastian Boerakker
+Author-email: Sebastian Höfer <hoefer@data-cybernetics.com>, Sebastian Boerakker <boerakker@data-cybernetics.com>
+License: MIT
+Requires-Dist: typer>=0.12.5
+Requires-Dist: copier>=9.10.2
+Requires-Dist: docker>=7.1.0
+Requires-Dist: dotenv>=0.9.9
+Requires-Dist: pinexq-client>=0.10.4rc1
+Requires-Dist: pydantic>=2.12.0
+Requires-Dist: rich>=14.2.0
+Requires-Dist: tomli>=2.3.0
+Requires-Dist: importlib>=1.0.4
+Maintainer: Sebastian Höfer, Sebastian Boerakker
+Maintainer-email: Sebastian Höfer <hoefer@data-cybernetics.com>, Sebastian Boerakker <boerakker@data-cybernetics.com>
+Requires-Python: >=3.13
+Description-Content-Type: text/markdown
+
+# pinexq CLI
+
+A minimal command-line interface for creating and running pinexq workers.
+
+Install (editable):
+
+- Using uv or pip, from the project root:
+  - `uv pip install -e .` or `pip install -e .`
+
+Usage:
+
+- Global options must precede the subcommand.
+- Authentication: Provide `--api-key` or set the `PINEXQ_API_KEY` environment variable. The CLI prefers the flag over the env var.

pinexq_cli-0.1.5.dist-info/RECORD

@@ -0,0 +1,23 @@
+pinexq/cli/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pinexq/cli/__main__.py,sha256=qhDROx55ETVxBT1OutXvTmmAKMwV7C_Wp1Rad6Xj7sg,586
+pinexq/cli/cmd/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pinexq/cli/cmd/cli.py,sha256=vJxAjqQwQylHDnSAJf4Gxpb58kex2jxzKzWCHbre_8A,4760
+pinexq/cli/cmd/deploy.py,sha256=s7uzltvbZZoSFc7GnIO8k4LUPogB84w1kBPK3Yqscs0,5336
+pinexq/cli/cmd/generate.py,sha256=PFLuh36cqHP6C0D8mpFaeYR2MHs8VDVwDTV-JInofxQ,2310
+pinexq/cli/cmd/initialization.py,sha256=F0Jde8uP77dg0pI0wJzaOvQbLhXxzTCTfQ8AyQ3GDxY,856
+pinexq/cli/cmd/register.py,sha256=B9oTkvbz-0vO9LYve5LmBWvyrL-omLu5k_kygMWEDSs,5089
+pinexq/cli/docker_tools/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pinexq/cli/docker_tools/client.py,sha256=i7zrsx_UPrNaivUhlJkyyONyB5veL8Y_VOFRDrL_n5U,9830
+pinexq/cli/pinexq_tools/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pinexq/cli/pinexq_tools/client.py,sha256=oyzNPxR8K5We344A_IxqvuL0t0TwgqZ23NZLlGUKREo,436
+pinexq/cli/pinexq_tools/info.py,sha256=mjpXrR2l_kgZvMKYm9wI_T9hwwzfs9oot7wM4NvW7Vw,996
+pinexq/cli/pinexq_tools/manifest.py,sha256=UuxD7I3vdoBLZmdYmDXS1AXwj2vDA2s65P55uJAIQUw,2485
+pinexq/cli/pinexq_tools/project.py,sha256=-HOKfuyNKeVAhGpaKZo_-B5vVHYm9teuvDe1JcB0ZLQ,3228
+pinexq/cli/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pinexq/cli/utils/console.py,sha256=xJ_p6spPCYiiBGXnV37kZJufO-MveByETX1EcGHbn1U,105
+pinexq/cli/utils/const.py,sha256=efk6g2WIYjGcRQ96dZzgRMDNmvToL51rXFFAZNqmsms,197
+pinexq/cli/utils/uv_utils.py,sha256=6X-jExlOD_OvpE8mprEuUaV-B6KLSUHWs_ZAVFl_c5c,267
+pinexq_cli-0.1.5.dist-info/WHEEL,sha256=KSLUh82mDPEPk0Bx0ScXlWL64bc8KmzIPNcpQZFV-6E,79
+pinexq_cli-0.1.5.dist-info/entry_points.txt,sha256=I_w5x5YdnwgZhuJK3tnZbqMNwMMIeCwqC0KDTK5eXpo,53
+pinexq_cli-0.1.5.dist-info/METADATA,sha256=dj6lfwEn3P2yWeGAv-bx71ICHbAWL6HujZgG7roAn_Y,1163
+pinexq_cli-0.1.5.dist-info/RECORD,,

pinexq_cli-0.1.5.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: uv 0.9.22
+Root-Is-Purelib: true
+Tag: py3-none-any

pinexq_cli-0.1.5.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+pinexq = pinexq.cli.__main__:main
+