xpk 0.14.4__py3-none-any.whl → 0.16.0__py3-none-any.whl

xpk/core/system_characteristics_test.py

@@ -14,7 +14,15 @@ See the License for the specific language governing permissions and
 limitations under the License.
 """
 
-from .system_characteristics import get_tpu_system_characteristics_map, SystemCharacteristics, AcceleratorType
+import pytest
+from .system_characteristics import (
+    get_tpu_system_characteristics_map,
+    generate_tpu_topologies,
+    DockerPlatform,
+    SystemCharacteristics,
+    AcceleratorType,
+    GpuConfig,
+)
 
 
 def test_get_tpu_system_characteristics_map_returns_correct_values_for_1x1_topology():
@@ -25,7 +33,8 @@ def test_get_tpu_system_characteristics_map_returns_correct_values_for_1x1_topol
       machine_type="test",
       supported_topologies=["1x1"],
       supports_sub_slicing=False,
-      requires_workload_policy=True,
+      docker_platform=DockerPlatform.AMD,
+      tpu_type_requires_workload_policy=False,
   )
 
   expected_system_characteristics = SystemCharacteristics(
@@ -37,7 +46,8 @@ def test_get_tpu_system_characteristics_map_returns_correct_values_for_1x1_topol
       accelerator_type=AcceleratorType.TPU,
       device_type="test-1",
       supports_sub_slicing=False,
-      requires_workload_policy=True,
+      docker_platform=DockerPlatform.AMD,
+      requires_workload_policy=False,
   )
   assert result == {
       "test-1": expected_system_characteristics,
@@ -53,7 +63,8 @@ def test_get_tpu_system_characteristics_map_returns_correct_values_for_2x2_topol
       machine_type="test",
       supported_topologies=["2x2"],
       supports_sub_slicing=False,
-      requires_workload_policy=True,
+      docker_platform=DockerPlatform.AMD,
+      tpu_type_requires_workload_policy=True,
   )
 
   expected_system_characteristics = SystemCharacteristics(
@@ -65,9 +76,121 @@ def test_get_tpu_system_characteristics_map_returns_correct_values_for_2x2_topol
       accelerator_type=AcceleratorType.TPU,
       device_type="test-8",
       supports_sub_slicing=False,
-      requires_workload_policy=True,
+      docker_platform=DockerPlatform.AMD,
+      requires_workload_policy=False,
   )
   assert result == {
       "test-8": expected_system_characteristics,
       "test-2x2": expected_system_characteristics,
   }
+
+
+def test_get_tpu_system_characteristics_map_returns_correct_values_for_2x2x2_topology():
+  result = get_tpu_system_characteristics_map(
+      prefix="test",
+      tensorcores_per_chip=2,
+      gke_accelerator="test",
+      machine_type="test",
+      supported_topologies=["2x2x2"],
+      supports_sub_slicing=False,
+      docker_platform=DockerPlatform.AMD,
+      tpu_type_requires_workload_policy=True,
+  )
+
+  expected_system_characteristics = SystemCharacteristics(
+      topology="2x2x2",
+      vms_per_slice=2,
+      gke_accelerator="test",
+      gce_machine_type="test",
+      chips_per_vm=4,
+      accelerator_type=AcceleratorType.TPU,
+      device_type="test-16",
+      supports_sub_slicing=False,
+      docker_platform=DockerPlatform.AMD,
+      requires_workload_policy=True,
+  )
+  assert result == {
+      "test-16": expected_system_characteristics,
+      "test-2x2x2": expected_system_characteristics,
+  }
+
+
+def test_get_tpu_system_characteristics_map_prefers_default_topologies():
+  result = get_tpu_system_characteristics_map(
+      prefix="test",
+      tensorcores_per_chip=2,
+      gke_accelerator="test",
+      machine_type="test",
+      supported_topologies=["4x4x4", "4x4x32", "4x8x16", "8x8x8"],
+      supports_sub_slicing=False,
+      docker_platform=DockerPlatform.AMD,
+      default_topologies=set(["4x8x16"]),
+  )
+
+  assert result["test-128"].topology == "4x4x4"
+  assert result["test-1024"].topology == "4x8x16"
+
+
+def test_generate_tpu_topologies_returns_correct_number_of_values_for_TPU_platforms():
+  v4 = generate_tpu_topologies(max_cubes=64, enforce_nondecreasing=False)
+  v5p = generate_tpu_topologies(max_cubes=140)
+  tpu7x = generate_tpu_topologies(max_cubes=144)
+
+  assert len(v4) == 800
+  assert len(v5p) == 414
+  assert len(tpu7x) == 432
+
+
+def test_generate_tpu_topologies_respects_constraints():
+  ordered_6_cubes = generate_tpu_topologies(
+      max_cubes=6, enforce_nondecreasing=True
+  )
+  non_ordered_6_cubes = generate_tpu_topologies(
+      max_cubes=6, enforce_nondecreasing=False
+  )
+
+  assert "8x4x4" not in ordered_6_cubes
+  assert "8x4x4" in non_ordered_6_cubes
+  assert "4x8x12" in ordered_6_cubes  # exactly 6 cubes
+  assert "4x8x12" in non_ordered_6_cubes  # exactly 6 cubes
+  assert "4x8x16" not in ordered_6_cubes  # too many cubes (8)
+  assert "4x8x16" not in non_ordered_6_cubes  # too many cubes (8)
+
+
+def test_generate_tpu_topologies_contains_sub_cube_slices():
+  one_cube = generate_tpu_topologies(max_cubes=1)
+
+  assert one_cube == ["2x2x1", "2x2x2", "2x2x4", "2x4x4", "4x4x4"]
+
+
+def test_system_characteristics_post_init_sets_workload_policy_for_gpu():
+  """Tests that __post_init__ correctly sets requires_workload_policy for GPUs."""
+  gpu_system = SystemCharacteristics(
+      topology="N/A",
+      vms_per_slice=1,
+      gke_accelerator="nvidia-l4",
+      gce_machine_type="g2-standard-12",
+      chips_per_vm=1,
+      accelerator_type=AcceleratorType.GPU,
+      device_type="l4-1",
+      supports_sub_slicing=False,
+      docker_platform=DockerPlatform.AMD,
+      gpu_config=GpuConfig(requires_topology=False),
+  )
+  assert gpu_system.requires_workload_policy is True
+
+
+def test_system_characteristics_post_init_throws_for_gpu_without_config():
+  """Tests that __post_init__ raises ValueError for GPU without gpu_config."""
+  with pytest.raises(ValueError, match="'gpu_config' was not provided"):
+    SystemCharacteristics(
+        topology="N/A",
+        vms_per_slice=1,
+        gke_accelerator="nvidia-l4",
+        gce_machine_type="g2-standard-12",
+        chips_per_vm=1,
+        accelerator_type=AcceleratorType.GPU,
+        device_type="l4-1",
+        supports_sub_slicing=False,
+        docker_platform=DockerPlatform.AMD,
+    )

xpk/core/telemetry.py

@@ -0,0 +1,263 @@
+"""
+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.
+"""
+
+import platform
+import uuid
+import json
+import os
+import time
+import sys
+import importlib
+import subprocess
+import tempfile
+import requests
+from enum import Enum
+from typing import Any
+from dataclasses import dataclass
+from .config import get_config, CLIENT_ID_KEY, SEND_TELEMETRY_KEY, __version__ as xpk_version
+from ..utils.execution_context import is_dry_run
+from ..utils.user_agent import get_user_agent
+from ..utils.feature_flags import FeatureFlags
+
+
+def should_send_telemetry():
+  return (
+      FeatureFlags.TELEMETRY_ENABLED
+      and get_config().get(SEND_TELEMETRY_KEY) != "false"
+  )
+
+
+def send_clearcut_payload(data: str, wait_to_complete: bool = False) -> None:
+  """Sends payload to clearcut endpoint."""
+  try:
+    file_path = _store_payload_in_temp_file(data)
+    if not _schedule_clearcut_background_flush(file_path, wait_to_complete):
+      _clearcut_flush(file_path)
+  except Exception:  # pylint: disable=broad-exception-caught
+    pass
+
+
+def _store_payload_in_temp_file(data: str) -> str:
+  with tempfile.NamedTemporaryFile(
+      mode="w", delete=False, encoding="utf-8"
+  ) as file:
+    json.dump(
+        {
+            "data": data,
+            "url": "https://play.googleapis.com/log",
+            "params": {"format": "json_proto"},
+            "headers": {"User-Agent": get_user_agent()},
+            "method": "POST",
+        },
+        file,
+    )
+    return file.name
+
+
+def _schedule_clearcut_background_flush(
+    file_path: str, wait_to_complete: bool
+) -> bool:
+  """Schedules clearcut background flush.
+
+  Args:
+    file_path: path to the temporary file where the events are stored.
+    wait_to_complete: whenever to wait for the background script completion.
+
+  Returns:
+    True if successful and False otherwise
+  """
+  with importlib.resources.path("xpk", "telemetry_uploader.py") as path:
+    if not os.path.exists(path):
+      return False
+
+    kwargs: dict[str, Any] = {}
+    if sys.platform == "win32":
+      kwargs["creationflags"] = (
+          subprocess.DETACHED_PROCESS | subprocess.CREATE_NO_WINDOW
+      )
+    else:
+      kwargs["start_new_session"] = True
+
+    process = subprocess.Popen(
+        args=[
+            sys.executable,
+            str(path),
+            file_path,
+        ],
+        stdout=sys.stdout if wait_to_complete else subprocess.DEVNULL,
+        stderr=sys.stderr if wait_to_complete else subprocess.DEVNULL,
+        **kwargs,
+    )
+    if wait_to_complete:
+      process.wait()
+    return True
+
+
+def _clearcut_flush(file_path: str) -> None:
+  with open(file_path, mode="r", encoding="utf-8") as file:
+    kwargs = json.load(file)
+    requests.request(**kwargs)
+    os.remove(file_path)
+
+
+class MetricsEventMetadataKey(Enum):
+  SESSION_ID = "XPK_SESSION_ID"
+  DRY_RUN = "XPK_DRY_RUN"
+  PYTHON_VERSION = "XPK_PYTHON_VERSION"
+  ZONE = "XPK_ZONE"
+  SYSTEM_CHARACTERISTICS = "XPK_SYSTEM_CHARACTERISTICS"
+  PROVISIONING_MODE = "XPK_PROVISIONING_MODE"
+  COMMAND = "XPK_COMMAND"
+  EXIT_CODE = "XPK_EXIT_CODE"
+  RUNNING_AS_PIP = "XPK_RUNNING_AS_PIP"
+  RUNNING_FROM_SOURCE = "XPK_RUNNING_FROM_SOURCE"
+
+
+@dataclass
+class _MetricsEvent:
+  time: float
+  type: str
+  name: str
+  metadata: dict[MetricsEventMetadataKey, str]
+
+
+class _MetricsCollector:
+  """Metrics collector for collecting various metrics and events across application."""
+
+  _events: list[_MetricsEvent] = []
+
+  def log_start(self, command: str) -> None:
+    """Logs start event."""
+    self._events.append(
+        _MetricsEvent(
+            time=time.time(),
+            type="commands",
+            name="start",
+            metadata={MetricsEventMetadataKey.COMMAND: command},
+        )
+    )
+
+  def log_complete(self, exit_code: int) -> None:
+    """Logs complete event."""
+    self._events.append(
+        _MetricsEvent(
+            time=time.time(),
+            type="commands",
+            name="complete",
+            metadata={MetricsEventMetadataKey.EXIT_CODE: str(exit_code)},
+        )
+    )
+
+  def log_custom(
+      self,
+      name: str,
+      metadata: dict[MetricsEventMetadataKey, str] | None = None,
+  ) -> None:
+    """Logs custom event."""
+    self._events.append(
+        _MetricsEvent(
+            time=time.time(),
+            type="custom",
+            name=name,
+            metadata=metadata if metadata is not None else {},
+        )
+    )
+
+  def flush(self) -> str:
+    """Flushes collected events into concord payload."""
+    result = _generate_payload(self._events)
+    self._events.clear()
+    return result
+
+
+MetricsCollector = _MetricsCollector()
+
+
+def _generate_payload(events: list[_MetricsEvent]) -> str:
+  base_concord_event = _get_base_concord_event()
+  base_event_metadata = _get_base_event_metadata()
+  serialized_events = []
+  for event in events:
+    metadata = {
+        **base_event_metadata,
+        **event.metadata,
+    }
+    serialized_events.append({
+        "event_time_ms": int(event.time * 1000),
+        "source_extension_json": json.dumps({
+            **base_concord_event,
+            "event_type": event.type,
+            "event_name": event.name,
+            "event_metadata": [
+                {"key": key.value, "value": value}
+                for key, value in metadata.items()
+            ],
+        }),
+    })
+
+  return json.dumps({
+      "client_info": {"client_type": "XPK"},
+      "log_source_name": "CONCORD",
+      "request_time_ms": int(time.time() * 1000),
+      "log_event": serialized_events,
+  })
+
+
+def _get_base_event_metadata() -> dict[MetricsEventMetadataKey, str]:
+  return {
+      MetricsEventMetadataKey.SESSION_ID: _get_session_id(),
+      MetricsEventMetadataKey.DRY_RUN: str(is_dry_run()).lower(),
+      MetricsEventMetadataKey.PYTHON_VERSION: platform.python_version(),
+      MetricsEventMetadataKey.RUNNING_AS_PIP: str(_is_running_as_pip()).lower(),
+      MetricsEventMetadataKey.RUNNING_FROM_SOURCE: str(
+          _is_running_from_source()
+      ).lower(),
+  }
+
+
+def _get_base_concord_event() -> dict[str, str]:
+  return {
+      "release_version": xpk_version,
+      "console_type": "XPK",
+      "client_install_id": _ensure_client_id(),
+  }
+
+
+def _is_running_as_pip() -> bool:
+  return os.path.basename(sys.argv[0]) == "xpk"
+
+
+def _is_running_from_source() -> bool:
+  current_path = os.path.abspath(os.path.realpath(__file__))
+  return (
+      "site-packages" not in current_path
+      and "dist-packages" not in current_path
+  )
+
+
+def _get_session_id() -> str:
+  return str(uuid.uuid4())
+
+
+def _ensure_client_id() -> str:
+  """Generates Client ID and stores in configuration if not already present."""
+  current_client_id = get_config().get(CLIENT_ID_KEY)
+  if current_client_id is not None:
+    return current_client_id
+
+  new_client_id = str(uuid.uuid4())
+  get_config().set(CLIENT_ID_KEY, new_client_id)
+  return new_client_id

xpk/core/telemetry_test.py

@@ -0,0 +1,211 @@
+"""
+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.
+"""
+
+import pytest
+import json
+from .config import get_config, CLIENT_ID_KEY, SEND_TELEMETRY_KEY
+from .telemetry import MetricsCollector, MetricsEventMetadataKey, should_send_telemetry
+from ..utils.execution_context import set_dry_run
+from ..utils.feature_flags import FeatureFlags
+from pytest_mock import MockerFixture
+
+
+@pytest.fixture(autouse=True)
+def setup_mocks(mocker: MockerFixture):
+  mocker.patch('xpk.core.telemetry._get_session_id', return_value='321231')
+  mocker.patch('time.time', return_value=0)
+  mocker.patch('platform.python_version', return_value='99.99.99')
+  mocker.patch('os.path.basename', return_value='xpk.py')
+  mocker.patch('os.path.abspath', return_value='/home/xpk_user')
+  set_dry_run(False)
+  get_config().set(CLIENT_ID_KEY, 'client_id')
+  yield
+  get_config().set(CLIENT_ID_KEY, None)
+
+
+@pytest.mark.parametrize(
+    argnames='feature_flag,config_value,expected',
+    argvalues=[
+        (True, 'true', True),
+        (False, 'true', False),
+        (True, None, True),
+        (True, 'false', False),
+    ],
+)
+def test_should_send_telemetry_returns_correct_value(
+    feature_flag: bool, config_value: str, expected: bool
+):
+  get_config().set(SEND_TELEMETRY_KEY, config_value)
+  FeatureFlags.TELEMETRY_ENABLED = feature_flag
+  assert should_send_telemetry() is expected
+
+
+def test_metrics_collector_generates_client_id_if_not_present():
+  get_config().set(CLIENT_ID_KEY, None)
+  MetricsCollector.log_start(command='test')
+  payload = json.loads(MetricsCollector.flush())
+  extension_json = json.loads(payload['log_event'][0]['source_extension_json'])
+  assert extension_json['client_install_id'] is not None
+  assert len(extension_json['client_install_id']) > 0
+
+
+def test_metrics_collector_logs_start_event_correctly():
+  MetricsCollector.log_start(command='test')
+  payload = json.loads(MetricsCollector.flush())
+  extension_json = json.loads(payload['log_event'][0]['source_extension_json'])
+  assert extension_json == {
+      'client_install_id': 'client_id',
+      'console_type': 'XPK',
+      'event_metadata': [
+          {'key': 'XPK_SESSION_ID', 'value': '321231'},
+          {'key': 'XPK_DRY_RUN', 'value': 'false'},
+          {'key': 'XPK_PYTHON_VERSION', 'value': '99.99.99'},
+          {'key': 'XPK_RUNNING_AS_PIP', 'value': 'false'},
+          {'key': 'XPK_RUNNING_FROM_SOURCE', 'value': 'true'},
+          {'key': 'XPK_COMMAND', 'value': 'test'},
+      ],
+      'event_name': 'start',
+      'event_type': 'commands',
+      'release_version': 'v0.0.0',
+  }
+
+
+def test_metrics_collector_generates_client_id_when_not_present():
+  get_config().set(CLIENT_ID_KEY, None)
+  MetricsCollector.log_start(command='test')
+  payload = json.loads(MetricsCollector.flush())
+  extension_json = json.loads(payload['log_event'][0]['source_extension_json'])
+  assert extension_json['client_install_id'] is not None
+  assert len(extension_json['client_install_id']) > 0
+
+
+def test_metrics_collector_logs_complete_event_correctly():
+  MetricsCollector.log_complete(exit_code=2)
+  payload = json.loads(MetricsCollector.flush())
+  extension_json = json.loads(payload['log_event'][0]['source_extension_json'])
+  assert extension_json == {
+      'client_install_id': 'client_id',
+      'console_type': 'XPK',
+      'event_metadata': [
+          {'key': 'XPK_SESSION_ID', 'value': '321231'},
+          {'key': 'XPK_DRY_RUN', 'value': 'false'},
+          {'key': 'XPK_PYTHON_VERSION', 'value': '99.99.99'},
+          {'key': 'XPK_RUNNING_AS_PIP', 'value': 'false'},
+          {'key': 'XPK_RUNNING_FROM_SOURCE', 'value': 'true'},
+          {'key': 'XPK_EXIT_CODE', 'value': '2'},
+      ],
+      'event_name': 'complete',
+      'event_type': 'commands',
+      'release_version': 'v0.0.0',
+  }
+
+
+def test_metrics_collector_logs_custom_event_correctly():
+  MetricsCollector.log_custom(
+      name='test', metadata={MetricsEventMetadataKey.PROVISIONING_MODE: 'flex'}
+  )
+  payload = json.loads(MetricsCollector.flush())
+  extension_json = json.loads(payload['log_event'][0]['source_extension_json'])
+  assert extension_json == {
+      'client_install_id': 'client_id',
+      'console_type': 'XPK',
+      'event_metadata': [
+          {'key': 'XPK_SESSION_ID', 'value': '321231'},
+          {'key': 'XPK_DRY_RUN', 'value': 'false'},
+          {'key': 'XPK_PYTHON_VERSION', 'value': '99.99.99'},
+          {'key': 'XPK_RUNNING_AS_PIP', 'value': 'false'},
+          {'key': 'XPK_RUNNING_FROM_SOURCE', 'value': 'true'},
+          {'key': 'XPK_PROVISIONING_MODE', 'value': 'flex'},
+      ],
+      'event_name': 'test',
+      'event_type': 'custom',
+      'release_version': 'v0.0.0',
+  }
+
+
+def test_metrics_collector_logs_correct_envelope():
+  MetricsCollector.log_start(command='test')
+  MetricsCollector.log_custom(
+      name='test', metadata={MetricsEventMetadataKey.PROVISIONING_MODE: 'flex'}
+  )
+  MetricsCollector.log_complete(exit_code=2)
+  payload = json.loads(MetricsCollector.flush())
+  assert payload['client_info'] == {'client_type': 'XPK'}
+  assert payload['log_source_name'] == 'CONCORD'
+  assert payload['request_time_ms'] == 0
+  assert len(payload['log_event']) == 3
+
+
+def test_metrics_collector_does_not_flush_event_twice():
+  MetricsCollector.log_start(command='test')
+  MetricsCollector.flush()
+  MetricsCollector.log_start(command='version')
+  payload = json.loads(MetricsCollector.flush())
+  assert len(payload['log_event']) == 1
+
+
+@pytest.mark.parametrize(
+    argnames='dry_run,expected', argvalues=[(False, 'false'), (True, 'true')]
+)
+def test_metrics_collector_logs_correct_dry_run_value(
+    dry_run: bool, expected: str
+):
+  set_dry_run(dry_run)
+  MetricsCollector.log_start(command='test')
+  payload = MetricsCollector.flush()
+  assert _get_metadata_value(payload, 'XPK_DRY_RUN') == expected
+
+
+@pytest.mark.parametrize(
+    argnames='basename,expected',
+    argvalues=[
+        ('xpk', 'true'),
+        ('xpk.py', 'false'),
+    ],
+)
+def test_metrics_collectors_logs_correct_running_as_pip_value(
+    basename: str, expected: str, mocker: MockerFixture
+):
+  mocker.patch('os.path.basename', return_value=basename)
+  MetricsCollector.log_start(command='test')
+  payload = MetricsCollector.flush()
+  assert _get_metadata_value(payload, 'XPK_RUNNING_AS_PIP') == expected
+
+
+@pytest.mark.parametrize(
+    argnames='abspath,expected',
+    argvalues=[
+        ('/site-packages/', 'false'),
+        ('/dist-packages/', 'false'),
+        ('/home/xpk_user', 'true'),
+    ],
+)
+def test_metrics_collectors_logs_correct_running_from_source_value(
+    abspath: str, expected: str, mocker: MockerFixture
+):
+  mocker.patch('os.path.abspath', return_value=abspath)
+  MetricsCollector.log_start(command='test')
+  payload = MetricsCollector.flush()
+  assert _get_metadata_value(payload, 'XPK_RUNNING_FROM_SOURCE') == expected
+
+
+def _get_metadata_value(payload_str: str, key: str) -> str | None:
+  payload = json.loads(payload_str)
+  metadata = json.loads(payload['log_event'][0]['source_extension_json'])[
+      'event_metadata'
+  ]
+  matching = (item['value'] for item in metadata if item['key'] == key)
+  return next(matching, None)

xpk/core/vertex.py

@@ -15,7 +15,7 @@ limitations under the License.
 """
 
 from ..utils.console import xpk_print
-from .resources import CLUSTER_METADATA_CONFIGMAP, get_cluster_configmap
+from .resources import ConfigMapType, get_cluster_configmap
 
 DEFAULT_VERTEX_TENSORBOARD_NAME = 'tb-instance'
 
@@ -65,8 +65,9 @@ def create_vertex_experiment(args) -> dict | None:
       tensorboard,
   )
 
-  metadata_configmap_name = f'{args.cluster}-{CLUSTER_METADATA_CONFIGMAP}'
-  cluster_config_map = get_cluster_configmap(metadata_configmap_name)
+  cluster_config_map = get_cluster_configmap(
+      args.cluster, ConfigMapType.METADATA
+  )
 
   if cluster_config_map is None or 'tensorboard_name' not in cluster_config_map:
     xpk_print(

xpk/core/workload_decorators/tcpx_decorator.py

@@ -39,12 +39,16 @@ def decorate_job(job_manifest: dict) -> dict:
   return job_manifest
 
 
-def decorate_jobset(jobset_manifest_str: str) -> str:
+def decorate_jobset(  # pylint: disable=dangerous-default-value
+    jobset_manifest_str: str,
+    sub_networks: list[str] = [],  # pylint: disable=unused-argument
+) -> str:
   """
   Decorates a JobSet manifest with the necessary components for tcpxo-daemon.
 
   Args:
     jobset_manifest_str: The JobSet manifest as a YAML string.
+    sub_networks: This parameter is accepted for interface consistency but is not used.
 
   Returns:
     The modified JobSet manifest as a YAML string.