xpk 0.6.0__py3-none-any.whl → 0.7.1__py3-none-any.whl

xpk/commands/info.py

@@ -14,19 +14,17 @@ See the License for the specific language governing permissions and
 limitations under the License.
 """
 
-from ..utils.console import xpk_exit, xpk_print
-from ..core.kueue import verify_kueuectl
-from .cluster import set_cluster_command
-from ..core.commands import (
-    run_command_for_value,
-)
-from ..core.core import (
-    add_zone_and_project,
-)
 import json
-from tabulate import tabulate
 from argparse import Namespace
 
+from tabulate import tabulate
+
+from ..core.commands import run_command_for_value
+from ..core.gcloud_context import add_zone_and_project
+from ..core.kueue import verify_kueuectl
+from ..utils.console import xpk_exit, xpk_print
+from .common import set_cluster_command
+
 table_fmt = 'plain'
 
 

xpk/commands/inspector.py

@@ -14,17 +14,13 @@ See the License for the specific language governing permissions and
 limitations under the License.
 """
 
+from ..core.cluster import get_cluster_credentials
 from ..core.commands import run_command_for_value
-from ..core.core import (
-    CLUSTER_METADATA_CONFIGMAP,
-    CLUSTER_RESOURCES_CONFIGMAP,
-    add_zone_and_project,
-    zone_to_region,
-)
+from ..core.gcloud_context import add_zone_and_project, zone_to_region
 from ..core.kueue import CLUSTER_QUEUE_NAME, LOCAL_QUEUE_NAME
-from ..utils.file import append_tmp_file, write_tmp_file
+from ..core.resources import CLUSTER_METADATA_CONFIGMAP, CLUSTER_RESOURCES_CONFIGMAP
 from ..utils.console import xpk_exit, xpk_print
-from .cluster import set_cluster_command
+from ..utils.file import append_tmp_file, write_tmp_file
 from .workload import get_workload_list
 
 
@@ -125,9 +121,7 @@ def inspector(args) -> None:
   xpk_print(args)
 
   add_zone_and_project(args)
-  set_cluster_command_code = set_cluster_command(args)
-  if set_cluster_command_code != 0:
-    xpk_exit(set_cluster_command_code)
+  get_cluster_credentials(args)
 
   inspector_file = write_tmp_file(
       '==================\nXPK inspector OUTPUT:\n==================\n'

xpk/commands/job.py

@@ -14,16 +14,18 @@ See the License for the specific language governing permissions and
 limitations under the License.
 """
 
-from .cluster import set_cluster_command
-from .kind import set_local_cluster_command
-from ..core.commands import run_command_for_value, run_command_with_updates
-from ..utils.console import xpk_exit, xpk_print
-from ..core.kjob import AppProfileDefaults
-from ..core.core import add_zone_and_project
-from ruamel.yaml import YAML
 import re
 import sys
 
+from ruamel.yaml import YAML
+
+from ..core.commands import run_command_for_value, run_command_with_updates
+from ..core.gcloud_context import add_zone_and_project
+from ..core.kjob import AppProfileDefaults
+from ..utils.console import xpk_exit, xpk_print
+from .common import set_cluster_command
+from .kind import set_local_cluster_command
+
 
 def job_info(args):
   """Run commands obtaining information about a job given by name.

xpk/commands/kind.py

@@ -18,9 +18,7 @@ from ..core.commands import (
     run_command_for_value,
     run_command_with_updates,
 )
-from ..core.core import (
-    set_jobset_on_cluster,
-)
+from ..core.cluster import set_jobset_on_cluster, setup_k8s_env
 from ..core.kjob import (
     verify_kjob_installed,
     prepare_kjob,
@@ -28,6 +26,13 @@ from ..core.kjob import (
 )
 from ..core.kueue import (
     install_kueue_on_cluster,
+    install_kueue_crs,
+    wait_for_kueue_available,
+)
+from ..core.storage import install_storage_crd
+from ..core.system_characteristics import (
+    SystemCharacteristics,
+    AcceleratorType,
 )
 from ..utils.console import (xpk_exit, xpk_print)
 
@@ -74,11 +79,36 @@ def cluster_create(args) -> None:
   if err_code > 0:
     xpk_exit(err_code)
 
-  xpk_print('Preparing kjob')
+  args.kind_cluster = True
   err_code = prepare_kjob(args)
   if err_code > 0:
     xpk_exit(err_code)
 
+  k8s_client = setup_k8s_env(args)
+  install_storage_crd(k8s_client)
+
+  xpk_print('Wait for Kueue to be fully available')
+  wait_for_kueue_available_code = wait_for_kueue_available(args)
+  if wait_for_kueue_available_code != 0:
+    xpk_exit(wait_for_kueue_available_code)
+
+  args.num_slices = 1
+  args.enable_pathways = False
+  system = SystemCharacteristics(
+      'N/A',
+      1,
+      'N/A',
+      'N/A',
+      1,
+      AcceleratorType['CPU'],
+      'kind',
+  )
+
+  xpk_print('Install Kueue Custom Resources')
+  enable_kueue_credentials_code = install_kueue_crs(args, system, None)
+  if enable_kueue_credentials_code != 0:
+    xpk_exit(enable_kueue_credentials_code)
+
   xpk_print('Kind commands done! Resources are created.')
   xpk_exit(0)
 

xpk/commands/kjob_common.py

@@ -0,0 +1,44 @@
+"""
+Copyright 2025 Google LLC
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+     https://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+"""
+
+from ..core.kjob import get_a3mega_pod_template_annotations, get_a3ultra_pod_template_annotations
+from ..core.capacity import H100_MEGA_DEVICE_TYPE, H200_DEVICE_TYPE
+from ..core.cluster import get_gpu_type_from_cluster
+
+
+def add_tcpxo_annotations(args, cmd: str) -> str:
+  tcpxo, interfaces, eth0 = get_a3mega_pod_template_annotations(args)
+  cmd += f" --pod-template-annotation {tcpxo} \\\n"
+  cmd += f" --pod-template-annotation {eth0} \\\n"
+  cmd += f" --pod-template-annotation {interfaces} "
+  return cmd
+
+
+def add_rdma_annotations(args, cmd) -> str:
+  eth0, interfaces = get_a3ultra_pod_template_annotations(args)
+  cmd += f" --pod-template-annotation {eth0} \\\n"
+  cmd += f" --pod-template-annotation {interfaces} \\\n"
+  return cmd
+
+
+def add_gpu_networking_annotations_to_command(args, cmd: str) -> str:
+  gpu_type = get_gpu_type_from_cluster(args)
+
+  if gpu_type == H100_MEGA_DEVICE_TYPE:
+    return add_tcpxo_annotations(args, cmd)
+  if gpu_type == H200_DEVICE_TYPE:
+    return add_rdma_annotations(args, cmd)
+  return cmd

xpk/commands/run.py

@@ -0,0 +1,128 @@
+"""
+Copyright 2025 Google LLC
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+     https://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+"""
+
+from argparse import Namespace
+
+from ..core.cluster import create_xpk_k8s_service_account
+from ..core.commands import run_command_with_full_controls
+from ..core.gcloud_context import add_zone_and_project
+from ..core.kueue import LOCAL_QUEUE_NAME
+from ..utils.console import xpk_exit, xpk_print
+from .common import set_cluster_command
+from ..core.kjob import JobTemplateDefaults, AppProfileDefaults, prepare_kjob, Kueue_TAS_annotation, get_gcsfuse_annotation
+from .kjob_common import add_gpu_networking_annotations_to_command
+from .kind import set_local_cluster_command
+
+
+def run(args: Namespace) -> None:
+  """Run task.
+     This function runs passed script in non-blocking manner.
+  Args:
+    args: user provided arguments for running the command.
+  Returns:
+    None
+  """
+  if not args.kind_cluster:
+    add_zone_and_project(args)
+    set_cluster_command_code = set_cluster_command(args)
+  else:
+    set_cluster_command_code = set_local_cluster_command(args)
+
+  if set_cluster_command_code != 0:
+    xpk_exit(set_cluster_command_code)
+
+  err_code = prepare_kjob(args)
+  if err_code > 0:
+    xpk_exit(err_code)
+  create_xpk_k8s_service_account()
+
+  submit_job(args)
+
+
+def submit_job(args: Namespace) -> None:
+  cmd = (
+      'kubectl kjob create slurm --profile'
+      f' {AppProfileDefaults.NAME.value} '
+      f' --localqueue {LOCAL_QUEUE_NAME} '
+      f" --pod-template-annotation '{Kueue_TAS_annotation}'"
+      f' --stream-container {JobTemplateDefaults.CONTAINER_NAME.value}'
+      f' --worker-container {JobTemplateDefaults.CONTAINER_NAME.value}'
+      ' --wait --rm  --first-node-ip'
+  )
+  cmd = add_gpu_networking_annotations_to_command(args, cmd)
+
+  gcsfuse_annotation = get_gcsfuse_annotation(args)
+  if gcsfuse_annotation is not None:
+    cmd += f' --pod-template-annotation {gcsfuse_annotation}'
+
+  if args.timeout:
+    cmd += f' --wait-timeout {args.timeout}s'
+
+  if args.ignore_unknown_flags:
+    cmd += ' --ignore-unknown-flags'
+
+  cmd += f' -- {args.script} --partition {LOCAL_QUEUE_NAME}'
+
+  if args.array is not None:
+    cmd += f' --array {args.array}'
+
+  if args.cpus_per_task is not None:
+    cmd += f' --cpus-per-task {args.cpus_per_task}'
+
+  if args.gpus_per_task is not None:
+    cmd += f' --gpus-per-task {args.gpus_per_task}'
+
+  if args.mem is not None:
+    cmd += f' --mem {args.mem}'
+
+  if args.mem_per_task is not None:
+    cmd += f' --mem-per-task {args.mem_per_task}'
+
+  if args.mem_per_cpu is not None:
+    cmd += f' --mem-per-cpu {args.mem_per_cpu}'
+
+  if args.mem_per_gpu is not None:
+    cmd += f' --mem-per-gpu {args.mem_per_gpu}'
+
+  if args.nodes is not None:
+    cmd += f' --nodes {args.nodes}'
+
+  if args.ntasks is not None:
+    cmd += f' --ntasks {args.ntasks}'
+
+  if args.output is not None:
+    cmd += f' --output {args.output}'
+
+  if args.error is not None:
+    cmd += f' --error {args.error}'
+
+  if args.input is not None:
+    cmd += f' --input {args.input}'
+
+  if args.job_name is not None:
+    cmd += f' --job-name {args.job_name}'
+
+  if args.chdir is not None:
+    cmd += f' --chdir {args.chdir}'
+
+  if args.time is not None:
+    cmd += f' --time {args.time}'
+
+  return_code = run_command_with_full_controls(cmd, 'run task', args)
+
+  if return_code != 0:
+    xpk_print(f'Running task returned ERROR {return_code}')
+    xpk_exit(return_code)

xpk/commands/shell.py

@@ -12,11 +12,16 @@ limitations under the License.
 """
 
 from ..core.commands import run_command_with_full_controls, run_command_for_value, run_command_with_updates
+from ..core.cluster import get_cluster_credentials, add_zone_and_project, create_xpk_k8s_service_account
 from ..utils.console import xpk_exit, xpk_print
 from argparse import Namespace
 
-from ..core.kjob import AppProfileDefaults, PodTemplateDefaults
-
+from ..core.kjob import (
+    AppProfileDefaults,
+    prepare_kjob,
+    get_pod_template_interactive_command,
+    get_gcsfuse_annotation,
+)
 
 exit_instructions = 'To exit the shell input "exit".'
 
@@ -45,6 +50,10 @@ def shell(args: Namespace):
 
 
 def get_existing_shell_pod_name(args: Namespace) -> str | None:
+  if not args.kind_cluster:
+    add_zone_and_project(args)
+    get_cluster_credentials(args)
+
   return_code, shell_name = run_command_for_value(
       command=(
           'kubectl get pods --no-headers --field-selector status.phase=Running'
@@ -70,11 +79,22 @@ def get_existing_shell_pod_name(args: Namespace) -> str | None:
 
 
 def connect_to_new_interactive_shell(args: Namespace) -> int:
+  err_code = prepare_kjob(args)
+  if err_code > 0:
+    xpk_exit(err_code)
+  create_xpk_k8s_service_account()
+
+  cmd = (
+      'kubectl-kjob create interactive --profile'
+      f' {AppProfileDefaults.NAME.value} --pod-running-timeout 180s'
+  )
+
+  gcsfuse_annotation = get_gcsfuse_annotation(args)
+  if gcsfuse_annotation is not None:
+    cmd += f' --pod-template-annotation {gcsfuse_annotation}'
+
   return run_command_with_full_controls(
-      command=(
-          'kubectl-kjob create interactive --profile'
-          f' {AppProfileDefaults.NAME.value} --pod-running-timeout 30s'
-      ),
+      command=cmd,
       task='Creating new interactive shell and entering it',
       global_args=args,
       instructions=exit_instructions,
@@ -87,7 +107,7 @@ def connect_to_existing_interactive_shell(
   return run_command_with_full_controls(
       command=(
           f'kubectl exec --stdin --tty {pod_name} --'
-          f' {PodTemplateDefaults.INTERACTIVE_COMMAND.value}'
+          f' {get_pod_template_interactive_command()}'
       ),
       task='Entering existing interactive shell',
       global_args=args,

xpk/commands/storage.py

@@ -0,0 +1,280 @@
+"""
+Copyright 2024 Google LLC
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+     https://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+"""
+
+from argparse import Namespace
+
+import yaml
+from kubernetes import client as k8s_client
+from kubernetes.client import ApiClient
+from kubernetes.client.rest import ApiException
+
+from ..core import gcsfuse
+from ..core.cluster import (
+    DEFAULT_NAMESPACE,
+    add_zone_and_project,
+    get_cluster_network,
+    setup_k8s_env,
+    update_cluster_with_gcpfilestore_driver_if_necessary,
+    update_cluster_with_gcsfuse_driver_if_necessary,
+    update_cluster_with_workload_identity_if_necessary,
+)
+from ..core.filestore import FilestoreClient, get_storage_class_name
+from ..core.kjob import (
+    KJOB_API_GROUP_NAME,
+    KJOB_API_GROUP_VERSION,
+    KJOB_API_VOLUME_BUNDLE_PLURAL,
+    create_volume_bundle_instance,
+)
+from ..core.storage import (
+    GCP_FILESTORE_TYPE,
+    GCS_FUSE_TYPE,
+    STORAGE_CRD_PLURAL,
+    XPK_API_GROUP_NAME,
+    XPK_API_GROUP_VERSION,
+    Storage,
+    create_storage_crds,
+    get_storage,
+    list_storages,
+    print_storages_for_cluster,
+)
+from ..utils.console import get_user_input, xpk_exit, xpk_print
+from ..utils.kubectl import apply_kubectl_manifest
+
+
+def storage_create(args: Namespace) -> None:
+  add_zone_and_project(args)
+  if args.type == GCP_FILESTORE_TYPE:
+    if args.instance is None:
+      args.instance = args.name
+
+    filestore_client = FilestoreClient(args.zone, args.instance, args.project)
+    filestore_exists = filestore_client.check_instance_exists()
+    if filestore_exists:
+      xpk_print(f"Filestore instance {args.instance} already exists.")
+      xpk_exit(1)
+    filestore_network = get_cluster_network(args)
+    xpk_print(
+        f"Creating Filestore instance {args.instance} in network:"
+        f" {filestore_network}"
+    )
+    filestore_client.create_instance(
+        vol=args.vol, size=args.size, tier=args.tier, network=filestore_network
+    )
+    if args.manifest is not None:
+      with open(args.manifest, "r", encoding="utf-8") as f:
+        manifest = list(yaml.safe_load_all(f))
+    else:
+      manifest = filestore_client.manifest(
+          args.name, args.vol, args.access_mode, filestore_network
+      )
+
+    k8s_api_client = setup_k8s_env(args)
+    create_storage_crds(k8s_api_client, args, manifest)
+    create_volume_bundle_instance(
+        k8s_api_client, args.name, manifest, args.readonly, args.mount_point
+    )
+    return_code = update_cluster_with_workload_identity_if_necessary(args)
+    if return_code > 0:
+      xpk_exit(return_code)
+    return_code = update_cluster_with_gcpfilestore_driver_if_necessary(args)
+    if return_code > 0:
+      xpk_exit(return_code)
+    apply_kubectl_manifest(k8s_api_client, manifest)
+
+
+def storage_delete(args: Namespace) -> None:
+  add_zone_and_project(args)
+  k8s_api_client = setup_k8s_env(args)
+  storages = list_storages(k8s_api_client)
+  filestore_client = FilestoreClient(args.zone, args.name, args.project)
+
+  if not filestore_client.check_instance_exists():
+    xpk_print(f"Filestore instance {args.name} does not exist.")
+    xpk_exit(1)
+
+  filestore_instance_name = filestore_client.get_instance_fullname()
+
+  children = [
+      storage
+      for storage in storages
+      if storage.bucket.startswith(filestore_instance_name)
+  ]
+
+  if children and not args.force:
+    detach = get_user_input(
+        "Deleting a filestore storage will destroy your filestore instance and"
+        " all its data in all volumes will be lost. Do you wish to delete the"
+        f" filestore instance {filestore_instance_name}?\n y (yes) / n (no):\n'"
+    )
+    if not detach:
+      xpk_print("Deleting storage canceled.")
+      xpk_exit(0)
+
+  for child in children:
+    delete_storage_resources(k8s_api_client, child)
+
+  filestore_client.delete_filestore_instance()
+
+
+def storage_attach(args: Namespace) -> None:
+  add_zone_and_project(args)
+  if args.type == GCP_FILESTORE_TYPE:
+    if args.instance is None:
+      args.instance = args.name
+
+    filestore_client = FilestoreClient(args.zone, args.instance, args.project)
+
+    filestore_exists = filestore_client.check_instance_exists()
+    if not filestore_exists:
+      xpk_print(f"Filestore instance {args.instance} does not exists.")
+      xpk_exit(1)
+
+    if args.manifest is not None:
+      with open(args.manifest, "r", encoding="utf-8") as f:
+        manifest = list(yaml.safe_load_all(f))
+    else:
+      filestore_network = get_cluster_network(args)
+      manifest = filestore_client.manifest(
+          args.name, args.vol, args.access_mode, filestore_network
+      )
+
+  else:  # args.type == GCS_FUSE_TYPE:
+    if args.manifest is None and args.size is None:
+      xpk_print("--size is required when attaching gcsfuse storage.")
+      xpk_exit(1)
+
+    if args.bucket is None:
+      args.bucket = args.name
+
+    if args.manifest is not None:
+      with open(args.manifest, "r", encoding="utf-8") as f:
+        manifest = list(yaml.safe_load_all(f))
+    else:
+      manifest = gcsfuse.manifest(
+          name=args.name, bucket=args.bucket, size=args.size
+      )
+
+  k8s_api_client = setup_k8s_env(args)
+  create_storage_crds(k8s_api_client, args, manifest)
+  create_volume_bundle_instance(
+      k8s_api_client, args.name, manifest, args.readonly, args.mount_point
+  )
+  return_code = update_cluster_with_workload_identity_if_necessary(args)
+  if return_code > 0:
+    xpk_exit(return_code)
+
+  # args.type can have only two values after parsing
+  return_code = (
+      update_cluster_with_gcsfuse_driver_if_necessary(args)
+      if args.type == GCS_FUSE_TYPE
+      else update_cluster_with_gcpfilestore_driver_if_necessary(args)
+  )
+  if return_code > 0:
+    xpk_exit(return_code)
+
+  apply_kubectl_manifest(k8s_api_client, manifest)
+
+
+def storage_list(args: Namespace) -> None:
+  k8s_api_client = setup_k8s_env(args)
+  storages = list_storages(k8s_api_client)
+  print_storages_for_cluster(storages)
+
+
+def storage_detach(args: Namespace) -> None:
+  k8s_api_client = setup_k8s_env(args)
+  storage = get_storage(k8s_api_client, args.name)
+  delete_storage_resources(k8s_api_client, storage)
+
+
+def delete_resource(api_call, resource_name: str, resource_kind: str) -> None:
+  """
+  Deletes a Kubernetes resource and handles potential API exceptions.
+
+  Args:
+    api_call: The function to call for deleting the resource.
+    resource_name: The name of the resource to delete.
+    resource_type: The type of the resource (e.g., "Persistent Volume Claim").
+  """
+  xpk_print(f"Deleting {resource_kind}:{resource_name}")
+  try:
+    api_call(resource_name)
+  except ApiException as e:
+    if e.status == 404:
+      xpk_print(
+          f"{resource_kind}: {resource_name} not found. "
+          f"Might be already deleted. Error: {e}"
+      )
+      return
+    else:
+      xpk_print(f"Encountered error during {resource_kind} deletion: {e}")
+      xpk_exit(1)
+  xpk_print(f"Deleted {resource_kind}:{resource_name}")
+
+
+def delete_storage_resources(k8s_api_client: ApiClient, storage: Storage):
+  """
+  Deletes storage PV, PVC, SC and custom resources (if they exist).
+
+  Args:
+    k8s_api_client: An ApiClient object for interacting with the Kubernetes API.
+    storage: Storage to delete
+  """
+  api_instance = k8s_client.CustomObjectsApi(k8s_api_client)
+  core_api = k8s_client.CoreV1Api()
+  storage_api = k8s_client.StorageV1Api()
+
+  delete_resource(
+      lambda name: core_api.delete_namespaced_persistent_volume_claim(
+          name, "default"
+      ),
+      storage.pvc,
+      "Persistent Volume Claim",
+  )
+
+  delete_resource(
+      core_api.delete_persistent_volume, storage.pv, "Persistent Volume"
+  )
+
+  if storage.type == GCP_FILESTORE_TYPE:
+    delete_resource(
+        storage_api.delete_storage_class,
+        get_storage_class_name(storage.name),
+        "Storage Class",
+    )
+
+  delete_resource(
+      lambda name: api_instance.delete_namespaced_custom_object(
+          namespace=DEFAULT_NAMESPACE,
+          name=name,
+          group=KJOB_API_GROUP_NAME,
+          version=KJOB_API_GROUP_VERSION,
+          plural=KJOB_API_VOLUME_BUNDLE_PLURAL,
+      ),
+      storage.name,
+      "VolumeBundle",
+  )
+
+  delete_resource(
+      lambda name: api_instance.delete_cluster_custom_object(
+          name=name,
+          group=XPK_API_GROUP_NAME,
+          version=XPK_API_GROUP_VERSION,
+          plural=STORAGE_CRD_PLURAL,
+      ),
+      storage.name,
+      "Storage",
+  )

xpk/commands/version.py

@@ -14,26 +14,14 @@ See the License for the specific language governing permissions and
 limitations under the License.
 """
 
-from argparse import Namespace
-import os
+from ..core.config import __version__
+from ..utils.console import xpk_print
 
-from ..core.commands import run_command_for_value
 
-XPK_VERSION = 'v0.6.0'
+def get_xpk_version() -> str:
+  return __version__
 
-from ..utils.console import xpk_exit, xpk_print
 
-
-def version(args: Namespace) -> None:
+def version(args) -> None:  # pylint: disable=unused-argument
   """Get version of xpk."""
-  xpk_print('xpk_version:', XPK_VERSION)
-  if os.path.exists(os.path.join(os.getcwd(), '.git')):
-    code, xpk_version = run_command_for_value(
-        'git rev-parse HEAD',
-        task='Get latest hash',
-        global_args=args,
-        quiet=True,
-    )
-    if code != 0:
-      xpk_exit(code)
-    xpk_print('git commit:', xpk_version.strip('\n'))
+  xpk_print('xpk_version:', __version__)