vaibify 0.0.0__py3-none-any.whl

vaibify/__init__.py

@@ -0,0 +1,4 @@
+try:
+    from ._version import __version__
+except ImportError:
+    __version__ = "unknown"

vaibify/__main__.py

@@ -0,0 +1,5 @@
+"""Allow running vaibify as ``python -m vaibify``."""
+
+from vaibify.cli.main import main
+
+main()

vaibify/_version.py

@@ -0,0 +1,24 @@
+# file generated by vcs-versioning
+# don't change, don't track in version control
+from __future__ import annotations
+
+__all__ = [
+    "__version__",
+    "__version_tuple__",
+    "version",
+    "version_tuple",
+    "__commit_id__",
+    "commit_id",
+]
+
+version: str
+__version__: str
+__version_tuple__: tuple[int | str, ...]
+version_tuple: tuple[int | str, ...]
+commit_id: str | None
+__commit_id__: str | None
+
+__version__ = version = '0.0.0'
+__version_tuple__ = version_tuple = (0, 0, 0)
+
+__commit_id__ = commit_id = None

vaibify/cli/__init__.py

@@ -0,0 +1 @@
+"""Vaibify CLI package."""

vaibify/cli/commandBuild.py

@@ -0,0 +1,133 @@
+"""CLI subcommand: vaibify build."""
+
+import os
+import subprocess
+import sys
+
+import click
+
+from .configLoader import fconfigResolveProject, fsDockerDir
+
+
+def fnBuildFromConfig(config, sDockerDir, bNoCache):
+    """Invoke the Docker image builder with the loaded configuration.
+
+    Uses lazy import so the CLI remains usable without Docker installed.
+    """
+    try:
+        from vaibify.docker.imageBuilder import fnBuildImage
+    except ImportError:
+        click.echo(
+            "Error: Docker support is not installed. "
+            "Install with: pip install vaibify[docker]"
+        )
+        sys.exit(1)
+    fnPrepareBuildContext(config, sDockerDir)
+    fnBuildImage(config, sDockerDir, bNoCache=bNoCache)
+    fnPruneDanglingImages()
+
+
+def fnPruneDanglingImages():
+    """Remove dangling Docker images left by previous builds."""
+    try:
+        resultPrune = subprocess.run(
+            ["docker", "image", "prune", "-f"],
+            capture_output=True, text=True, timeout=30,
+        )
+        if resultPrune.returncode == 0:
+            listLines = resultPrune.stdout.strip().split("\n")
+            sLastLine = listLines[-1] if listLines else ""
+            if "reclaimed" in sLastLine.lower():
+                click.echo(f"[vaib] {sLastLine}")
+    except Exception:
+        pass
+
+
+def fnPrepareBuildContext(config, sDockerDir):
+    """Generate all config-derived files in the Docker build context."""
+    from vaibify.config.containerConfig import (
+        fnGenerateContainerConf,
+    )
+    fnGenerateContainerConf(
+        config, os.path.join(sDockerDir, "container.conf")
+    )
+    fnWriteSystemPackages(config, sDockerDir)
+    fnWritePythonPackages(config, sDockerDir)
+    fnWritePipInstallFlags(config, sDockerDir)
+    fnWriteBinariesEnv(config, sDockerDir)
+    fnCopyDirectorScript(sDockerDir)
+
+
+def fnWriteSystemPackages(config, sDockerDir):
+    """Write listSystemPackages to system-packages.txt."""
+    sPath = os.path.join(sDockerDir, "system-packages.txt")
+    sContent = "\n".join(config.listSystemPackages) + "\n"
+    _fnWriteFile(sPath, sContent)
+
+
+def fnWritePythonPackages(config, sDockerDir):
+    """Write listPythonPackages to requirements.txt."""
+    sPath = os.path.join(sDockerDir, "requirements.txt")
+    sContent = "\n".join(config.listPythonPackages) + "\n"
+    _fnWriteFile(sPath, sContent)
+
+
+def fnWritePipInstallFlags(config, sDockerDir):
+    """Write sPipInstallFlags to pip-flags.txt."""
+    sPath = os.path.join(sDockerDir, "pip-flags.txt")
+    _fnWriteFile(sPath, config.sPipInstallFlags.strip() + "\n")
+
+
+def fnWriteBinariesEnv(config, sDockerDir):
+    """Write listBinaries to binaries.env as KEY=VALUE lines."""
+    sPath = os.path.join(sDockerDir, "binaries.env")
+    listLines = []
+    for dictBinary in config.listBinaries:
+        sName = dictBinary.get("name", "")
+        sBinPath = dictBinary.get("path", "")
+        if sName and sBinPath:
+            listLines.append(f"{sName}={sBinPath}")
+    sContent = "\n".join(listLines) + "\n"
+    _fnWriteFile(sPath, sContent)
+
+
+def fnCopyDirectorScript(sDockerDir):
+    """Copy director.py into the Docker build context."""
+    import shutil
+    import pathlib
+    sSourcePath = str(
+        pathlib.Path(__file__).resolve().parents[1]
+        / "gui" / "director.py"
+    )
+    sDestPath = os.path.join(sDockerDir, "director.py")
+    shutil.copy2(sSourcePath, sDestPath)
+
+
+def _fnWriteFile(sPath, sContent):
+    """Write string content to a file."""
+    with open(sPath, "w") as fileHandle:
+        fileHandle.write(sContent)
+
+
+@click.command("build")
+@click.option(
+    "--no-cache",
+    "bNoCache",
+    is_flag=True,
+    default=False,
+    help="Build the image without using Docker cache.",
+)
+@click.option(
+    "--project", "-p", "sProjectName", default=None,
+    help="Project name (omit if in a project directory "
+    "or only one project exists).",
+)
+def build(bNoCache, sProjectName):
+    """Build the Vaibify Docker image from vaibify.yml."""
+    config = fconfigResolveProject(sProjectName)
+    sDockerDir = fsDockerDir()
+    click.echo(
+        f"Building image {config.sProjectName}:latest ..."
+    )
+    fnBuildFromConfig(config, sDockerDir, bNoCache)
+    click.echo("Build complete.")

vaibify/cli/commandCat.py

@@ -0,0 +1,39 @@
+"""CLI subcommand: vaibify cat."""
+
+import sys
+
+import click
+
+from .configLoader import fconfigResolveProject
+from .commandUtilsDocker import (
+    fconnectionRequireDocker,
+    fsRequireRunningContainer,
+)
+
+
+def _fsNormalizePath(sPath):
+    """Prepend /workspace/ if the path is not absolute."""
+    if not sPath.startswith("/"):
+        return f"/workspace/{sPath}"
+    return sPath
+
+
+@click.command("cat")
+@click.option(
+    "--project", "-p", "sProjectName", default=None,
+    help="Project name.",
+)
+@click.argument("path")
+def cat(sProjectName, path):
+    """Print file contents from the container."""
+    configProject = fconfigResolveProject(sProjectName)
+    connectionDocker = fconnectionRequireDocker()
+    sContainerName = fsRequireRunningContainer(configProject)
+    sNormalized = _fsNormalizePath(path)
+    iExitCode, sOutput = connectionDocker.ftResultExecuteCommand(
+        sContainerName, f"cat {sNormalized}"
+    )
+    if iExitCode != 0:
+        click.echo(f"Error: {sOutput.strip()}")
+        sys.exit(2)
+    click.echo(sOutput, nl=False)

vaibify/cli/commandConfig.py

@@ -0,0 +1,82 @@
+"""CLI subcommand group: vaibify config."""
+
+import pathlib
+import sys
+
+import click
+import yaml
+
+from .configLoader import fconfigResolveProject, fsConfigPath
+
+
+def fnWriteYaml(dictData, sPath):
+    """Write a dictionary to a YAML file."""
+    try:
+        with open(sPath, "w") as fileHandle:
+            yaml.dump(dictData, fileHandle, default_flow_style=False)
+    except OSError as error:
+        click.echo(f"Error writing {sPath}: {error}")
+        sys.exit(1)
+
+
+def fdictLoadYamlFile(sPath):
+    """Load and return a YAML file as a dictionary."""
+    if not pathlib.Path(sPath).is_file():
+        click.echo(f"Error: File '{sPath}' not found.")
+        sys.exit(1)
+    try:
+        with open(sPath, "r") as fileHandle:
+            dictData = yaml.safe_load(fileHandle)
+    except yaml.YAMLError as error:
+        click.echo(f"Error parsing {sPath}: {error}")
+        sys.exit(1)
+    if dictData is None:
+        return {}
+    return dictData
+
+
+@click.group("config")
+def config():
+    """View and manage Vaibify configuration."""
+    pass
+
+
+@config.command("export")
+@click.option(
+    "--project", "-p", "sProjectName", default=None,
+    help="Project name (omit if in a project directory "
+    "or only one project exists).",
+)
+@click.argument("sfilepath", metavar="FILE")
+def configExport(sProjectName, sfilepath):
+    """Export the current configuration to a YAML file."""
+    from vaibify.config.projectConfig import fnSaveToFile
+    configProject = fconfigResolveProject(sProjectName)
+    fnSaveToFile(configProject, sfilepath)
+    click.echo(f"Configuration exported to {sfilepath}")
+
+
+@config.command("import")
+@click.argument("sfilepath", metavar="FILE")
+def configImport(sfilepath):
+    """Import configuration from a YAML file and overwrite the current config."""
+    dictNewConfig = fdictLoadYamlFile(sfilepath)
+    sConfigPath = fsConfigPath()
+    bExists = pathlib.Path(sConfigPath).is_file()
+    if bExists and not click.confirm(
+        "Overwrite existing vaibify.yml?"
+    ):
+        click.echo("Aborted.")
+        return
+    fnWriteYaml(dictNewConfig, sConfigPath)
+    click.echo(f"Configuration imported from {sfilepath}")
+
+
+@config.command("edit")
+def configEdit():
+    """Open vaibify.yml in the default editor."""
+    sConfigPath = fsConfigPath()
+    if not pathlib.Path(sConfigPath).is_file():
+        click.echo("Error: vaibify.yml not found.")
+        sys.exit(1)
+    click.edit(filename=sConfigPath)

vaibify/cli/commandDestroy.py

@@ -0,0 +1,72 @@
+"""CLI subcommand: vaibify destroy."""
+
+import sys
+
+import click
+
+from .configLoader import fbDockerAvailable, fconfigResolveProject
+
+
+def fnRemoveVolume(sVolumeName):
+    """Remove a Docker volume by name."""
+    import docker
+    dockerClient = docker.from_env()
+    try:
+        volume = dockerClient.volumes.get(sVolumeName)
+        volume.remove(force=True)
+        click.echo(f"Removed volume: {sVolumeName}")
+    except docker.errors.NotFound:
+        click.echo(f"Volume '{sVolumeName}' does not exist.")
+    except docker.errors.APIError as error:
+        click.echo(f"Error removing volume: {error}")
+        sys.exit(1)
+
+
+def fnRemoveImage(sFullName):
+    """Remove a Docker image by full name."""
+    import docker
+    dockerClient = docker.from_env()
+    try:
+        dockerClient.images.remove(sFullName, force=True)
+        click.echo(f"Removed image: {sFullName}")
+    except docker.errors.ImageNotFound:
+        click.echo(f"Image '{sFullName}' does not exist.")
+    except docker.errors.APIError as error:
+        click.echo(f"Error removing image: {error}")
+        sys.exit(1)
+
+
+def fnRequireDocker():
+    """Exit with an error if the Docker Python SDK is not installed."""
+    if not fbDockerAvailable():
+        click.echo(
+            "Error: Docker support is not installed. "
+            "Install with: pip install vaibify[docker]"
+        )
+        sys.exit(1)
+
+
+@click.command("destroy")
+@click.option(
+    "--project", "-p", "sProjectName", default=None,
+    help="Project name (omit if in a project directory "
+    "or only one project exists).",
+)
+def destroy(sProjectName):
+    """Remove the Vaibify workspace volume and optionally the image."""
+    fnRequireDocker()
+    config = fconfigResolveProject(sProjectName)
+    sVolumeName = f"{config.sProjectName}-workspace"
+    sFullName = f"{config.sProjectName}:latest"
+    if not click.confirm(
+        f"This will remove the workspace volume "
+        f"'{sVolumeName}'. Continue?"
+    ):
+        click.echo("Aborted.")
+        return
+    fnRemoveVolume(sVolumeName)
+    if click.confirm(
+        "Also remove the Docker image?", default=False
+    ):
+        fnRemoveImage(sFullName)
+    click.echo("Destroy complete.")

vaibify/cli/commandInit.py

@@ -0,0 +1,117 @@
+"""CLI subcommand: vaibify init."""
+
+import pathlib
+import shutil
+import sys
+
+import click
+
+from .configLoader import fsConfigPath
+
+from vaibify.config.registryManager import fnAddProject
+
+_sTemplatesDir = "templates"
+
+
+def flistAvailableTemplates():
+    """Return a list of template directory names shipped with the package."""
+    sPackageRoot = str(pathlib.Path(__file__).resolve().parents[2])
+    sTemplatesPath = pathlib.Path(sPackageRoot) / _sTemplatesDir
+    if not sTemplatesPath.is_dir():
+        return []
+    return sorted(
+        d.name for d in sTemplatesPath.iterdir() if d.is_dir()
+    )
+
+
+def fsTemplatePath(sTemplateName):
+    """Return the absolute path to a named template directory."""
+    sPackageRoot = str(pathlib.Path(__file__).resolve().parents[2])
+    return str(pathlib.Path(sPackageRoot) / _sTemplatesDir / sTemplateName)
+
+
+def fnPrintAvailableTemplates():
+    """Print available template names to stdout."""
+    listTemplates = flistAvailableTemplates()
+    if not listTemplates:
+        click.echo("No templates found.")
+        return
+    click.echo("Available templates:")
+    for sName in listTemplates:
+        click.echo(f"  - {sName}")
+
+
+def fbConfigExists():
+    """Return True if vaibify.yml exists in the current directory."""
+    return pathlib.Path(fsConfigPath()).is_file()
+
+
+def fnCopyTemplate(sTemplateName):
+    """Copy template files into the current directory."""
+    sSourcePath = fsTemplatePath(sTemplateName)
+    if not pathlib.Path(sSourcePath).is_dir():
+        click.echo(f"Error: Template '{sTemplateName}' not found.")
+        sys.exit(1)
+    fnCopyDirectoryContents(sSourcePath, str(pathlib.Path.cwd()))
+
+
+def fnCopyDirectoryContents(sSourceDir, sDestDir):
+    """Copy all files from sSourceDir into sDestDir."""
+    sSource = pathlib.Path(sSourceDir)
+    for sItem in sSource.iterdir():
+        sDest = pathlib.Path(sDestDir) / sItem.name
+        if sItem.is_dir():
+            shutil.copytree(str(sItem), str(sDest), dirs_exist_ok=True)
+        else:
+            shutil.copy2(str(sItem), str(sDest))
+
+
+def fnWriteDefaultConfig(sTemplateName):
+    """Write a minimal vaibify.yml using the ProjectConfig defaults."""
+    from vaibify.config.projectConfig import (
+        ProjectConfig,
+        fnSaveToFile,
+    )
+    sConfigPath = fsConfigPath()
+    config = ProjectConfig(sProjectName=sTemplateName)
+    fnSaveToFile(config, sConfigPath)
+    click.echo(f"Created {sConfigPath}")
+
+
+def fnRegisterProject():
+    """Register the current directory in the global project registry."""
+    try:
+        fnAddProject(str(pathlib.Path.cwd()))
+    except (ValueError, FileNotFoundError):
+        pass
+
+
+@click.command("init")
+@click.option(
+    "--template",
+    "sTemplateName",
+    default=None,
+    help="Name of the project template to use.",
+)
+@click.option(
+    "--force",
+    "bForce",
+    is_flag=True,
+    default=False,
+    help="Overwrite existing vaibify.yml.",
+)
+def init(sTemplateName, bForce):
+    """Initialize a new Vaibify project in the current directory."""
+    if sTemplateName is None:
+        fnPrintAvailableTemplates()
+        return
+    if fbConfigExists() and not bForce:
+        click.echo(
+            "Error: vaibify.yml already exists. "
+            "Use --force to overwrite."
+        )
+        sys.exit(1)
+    fnCopyTemplate(sTemplateName)
+    fnWriteDefaultConfig(sTemplateName)
+    fnRegisterProject()
+    click.echo(f"Initialized Vaibify project with '{sTemplateName}'.")

vaibify/cli/commandLs.py

@@ -0,0 +1,59 @@
+"""CLI subcommand: vaibify ls."""
+
+import sys
+
+import click
+
+from .configLoader import fconfigResolveProject
+from .commandUtilsDocker import (
+    fconnectionRequireDocker,
+    fsRequireRunningContainer,
+    fnPrintJson,
+    fbShouldOutputJson,
+)
+
+
+def _fsNormalizePath(sPath):
+    """Prepend /workspace/ if the path is not absolute."""
+    if sPath and not sPath.startswith("/"):
+        return f"/workspace/{sPath}"
+    return sPath
+
+
+def _flistParseDirectoryListing(sOutput):
+    """Parse ls output into a list of filename strings."""
+    listFiles = []
+    for sLine in sOutput.splitlines():
+        sStripped = sLine.strip()
+        if sStripped:
+            listFiles.append(sStripped)
+    return listFiles
+
+
+@click.command("ls")
+@click.option(
+    "--project", "-p", "sProjectName", default=None,
+    help="Project name.",
+)
+@click.option(
+    "--json", "bJson", is_flag=True, default=False,
+    help="Output in JSON format.",
+)
+@click.argument("path", default="/workspace")
+def ls(sProjectName, bJson, path):
+    """List files in the container workspace."""
+    configProject = fconfigResolveProject(sProjectName)
+    connectionDocker = fconnectionRequireDocker()
+    sContainerName = fsRequireRunningContainer(configProject)
+    sNormalized = _fsNormalizePath(path)
+    iExitCode, sOutput = connectionDocker.ftResultExecuteCommand(
+        sContainerName, f"ls -1 {sNormalized}"
+    )
+    if iExitCode != 0:
+        click.echo(f"Error: {sOutput.strip()}")
+        sys.exit(2)
+    if fbShouldOutputJson(bJson):
+        listFiles = _flistParseDirectoryListing(sOutput)
+        fnPrintJson({"sPath": sNormalized, "listFiles": listFiles})
+    else:
+        click.echo(sOutput.rstrip())

vaibify/cli/commandPublish.py

@@ -0,0 +1,21 @@
+"""CLI subcommand group: vaibify publish (stub)."""
+
+import click
+
+
+@click.group("publish")
+def publish():
+    """Publish reproducible archives and workflows."""
+    pass
+
+
+@publish.command("archive")
+def publishArchive():
+    """Create a reproducible archive of the current project."""
+    click.echo("Not yet implemented.")
+
+
+@publish.command("workflow")
+def publishWorkflow():
+    """Publish a workflow definition for the current project."""
+    click.echo("Not yet implemented.")