dxpy 0.402.0__tar.gz → 0.404.0__tar.gz

{dxpy-0.402.0 → dxpy-0.404.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: dxpy
-Version: 0.402.0
+Version: 0.404.0
 Summary: DNAnexus Platform API bindings for Python
 Home-page: https://github.com/dnanexus/dx-toolkit
 Author: Aleksandra Zalcman, Andrey Kislyuk, Anurag Biyani, Geet Duggal, Katherine Lai, Kurt Jensen, Marek Hrvol, Ohad Rodeh, Phil Sung

{dxpy-0.402.0 → dxpy-0.404.0}/dxpy/app_builder.py

@@ -64,12 +64,65 @@ class AppBuilderException(Exception):
     """
     pass
 
+def _validate_system_requirements(system_requirements):
+    """
+    Validates systemRequirements section of dxapp.json for instanceTypeSelector constraints.
+
+    :param system_requirements: The systemRequirements section from runSpec
+    :type system_requirements: dict
+    :raises AppBuilderException: If validation fails
+    """
+    if not isinstance(system_requirements, dict):
+        return
+
+    for entry_point, requirements in system_requirements.items():
+        if not isinstance(requirements, dict):
+            continue
+
+        has_instance_type = 'instanceType' in requirements
+        has_instance_type_selector = 'instanceTypeSelector' in requirements
+        has_cluster_spec = 'clusterSpec' in requirements
+
+        # Check mutual exclusivity: instanceType and instanceTypeSelector
+        if has_instance_type and has_instance_type_selector:
+            raise AppBuilderException(
+                "instanceType and instanceTypeSelector keywords are mutually exclusive "
+                "in systemRequirements for entry point '{}'".format(entry_point)
+            )
+
+        # Check mutual exclusivity: instanceTypeSelector and clusterSpec
+        if has_instance_type_selector and has_cluster_spec:
+            raise AppBuilderException(
+                "instanceTypeSelector and clusterSpec keywords are mutually exclusive "
+                "in systemRequirements for entry point '{}'".format(entry_point)
+            )
+
 def _validate_applet_spec(applet_spec):
     if 'runSpec' not in applet_spec:
         raise AppBuilderException("Required field 'runSpec' not found in dxapp.json")
 
+    # Validate systemRequirements for instanceTypeSelector constraints in runSpec
+    if 'systemRequirements' in applet_spec.get('runSpec', {}):
+        _validate_system_requirements(applet_spec['runSpec']['systemRequirements'])
+
+    # Validate systemRequirements in regionalOptions for each region
+    regional_options = applet_spec.get('regionalOptions', {})
+    if isinstance(regional_options, dict):
+        for region, options in regional_options.items():
+            if isinstance(options, dict) and 'systemRequirements' in options:
+                _validate_system_requirements(options['systemRequirements'])
+
 def _validate_app_spec(app_spec):
-    pass
+    # Validate systemRequirements for instanceTypeSelector constraints in runSpec
+    if 'runSpec' in app_spec and 'systemRequirements' in app_spec['runSpec']:
+        _validate_system_requirements(app_spec['runSpec']['systemRequirements'])
+
+    # Validate systemRequirements in regionalOptions for each region
+    regional_options = app_spec.get('regionalOptions', {})
+    if isinstance(regional_options, dict):
+        for region, options in regional_options.items():
+            if isinstance(options, dict) and 'systemRequirements' in options:
+                _validate_system_requirements(options['systemRequirements'])
 
 def _get_applet_spec(src_dir):
     applet_spec_file = os.path.join(src_dir, "dxapp.json")

{dxpy-0.402.0 → dxpy-0.404.0}/dxpy/cli/parsers.py

@@ -222,6 +222,45 @@ def process_extra_args(args):
         except:
             raise DXParserError('Value given for --extra-args could not be parsed as JSON')
 
+        # Validate that instanceTypeSelector is not specified in systemRequirements
+        def check_system_requirements(sys_reqs, context="systemRequirements"):
+            if isinstance(sys_reqs, dict):
+                for entry_point, reqs in sys_reqs.items():
+                    if isinstance(reqs, dict) and 'instanceTypeSelector' in reqs:
+                        raise DXParserError(
+                            'instanceTypeSelector cannot be specified in runtime --extra-args. '
+                            'It can only be defined in the dxapp.json at build time.'
+                        )
+
+        if 'systemRequirements' in args.extra_args:
+            check_system_requirements(args.extra_args['systemRequirements'])
+
+        # Check systemRequirementsByExecutable (double-nested structure: executable -> entrypoint -> requirements)
+        if 'systemRequirementsByExecutable' in args.extra_args:
+            sys_reqs_by_exec = args.extra_args['systemRequirementsByExecutable']
+            if isinstance(sys_reqs_by_exec, dict):
+                for executable_id, entrypoints in sys_reqs_by_exec.items():
+                    if isinstance(entrypoints, dict):
+                        check_system_requirements(entrypoints, f"systemRequirementsByExecutable.{executable_id}")
+
+        # Also check regionalOptions
+        if 'regionalOptions' in args.extra_args:
+            regional_opts = args.extra_args['regionalOptions']
+            if isinstance(regional_opts, dict):
+                for region, region_spec in regional_opts.items():
+                    if isinstance(region_spec, dict):
+                        if 'systemRequirements' in region_spec:
+                            check_system_requirements(region_spec['systemRequirements'],
+                                                     f"regionalOptions.{region}.systemRequirements")
+                        # Also check systemRequirementsByExecutable within regionalOptions
+                        if 'systemRequirementsByExecutable' in region_spec:
+                            sys_reqs_by_exec = region_spec['systemRequirementsByExecutable']
+                            if isinstance(sys_reqs_by_exec, dict):
+                                for executable_id, entrypoints in sys_reqs_by_exec.items():
+                                    if isinstance(entrypoints, dict):
+                                        check_system_requirements(entrypoints,
+                                                                f"regionalOptions.{region}.systemRequirementsByExecutable.{executable_id}")
+
 exec_input_args = argparse.ArgumentParser(add_help=False)
 exec_input_args.add_argument('-i', '--input', help=fill('An input to be added using "<input name>[:<class>]=<input value>" (provide "class" if there is no input spec; it can be any job IO class, e.g. "string", "array:string", or "array"; if "class" is "array" or not specified, the value will be attempted to be parsed as JSON and is otherwise treated as a string)', width_adjustment=-24), action='append')
 exec_input_args.add_argument('-j', '--input-json', help=fill('The full input JSON (keys=input field names, values=input field values)', width_adjustment=-24))

{dxpy-0.402.0 → dxpy-0.404.0}/dxpy/nextflow/app_asset_projects_ids_prod.json

@@ -6,5 +6,6 @@
     "aws:us-east-1": "project-B6JG897KGbkGb6Z7pQ9Q02jG",
     "azure:westeurope": "project-FGZZFkjBPJqBXq1X84pq4VJf",
     "azure:westus": "project-F3vk1q09FX8Jxxp20pq6z8P9",
+    "azure:uksouth-ofh": "project-GK404k924z9199Bv062PkYZk",
     "oci:us-ashburn-1": "project-J1q0ZJV6VQg98Q4Bz36JbQKJ"
 }

{dxpy-0.402.0 → dxpy-0.404.0}/dxpy/nextflow/app_asset_projects_ids_staging.json

@@ -6,5 +6,6 @@
     "aws:us-east-1": "project-G0zG4B808VFFYVz84FQkvF1K",
     "azure:westeurope": "project-G0zG4BQBq1XQby2F4FqQpPXv",
     "azure:westus": "project-G0zG4B09ZJ5gx1Vz4Fb8Q9XX",
+    "azure:uksouth-ofh": "project-GJkPq8V2X73240P46Y5FKZ41",
     "oci:us-ashburn-1": "project-J1q0ZJV6z2pJXY2Qqv8xvX5G"
 }

{dxpy-0.402.0 → dxpy-0.404.0}/dxpy/nextflow/awscli_assets.json

@@ -4,6 +4,7 @@
   "aws:eu-west-2-g": "record-Gyv6ykBKQqy2K41YGfqpxYvF",
   "aws:me-south-1": "record-Gyv70B932Vy4bg78PFvbB4Q7",
   "aws:us-east-1": "record-Gyv6Q9j0PPgJQJ72226Gz7j7",
+  "azure:uksouth-ofh": "record-J5XVQjV24ZVFvPPbqVpBFzxB",
   "azure:westeurope": "record-Gyv73f0BKJkvjx5FPJq6F22b",
   "azure:westus": "record-Gyv77Vj9zv30Pfx8V890xQ6Q",
   "oci:us-ashburn-1": "record-J30Z62V6ZVX41GJBgkxbkFzp"

{dxpy-0.402.0 → dxpy-0.404.0}/dxpy/nextflow/awscli_assets.staging.json

@@ -4,6 +4,7 @@
   "aws:eu-west-2-g": "record-GyqkvqpK06ffFb9V8g80f7Gg",
   "aws:me-south-1": "record-Gyqp5F13fKQ44GfVP0VkKZ0z",
   "aws:us-east-1": "record-GyqkB3j08Gb14Pf0P8x5Xq5Q",
+  "azure:uksouth-ofh": "record-J5XV1P92FJvy4V4KGX8PYZ1j",
   "azure:westeurope": "record-Gyqp8g8B3BVZ4GfVP0VkKZ15",
   "azure:westus": "record-GyqpG7Q9Z3044GfVP0VkKZ1J",
   "oci:us-ashburn-1": "record-J30Xb1k6p6JxZFPzfpBfY6Qq"

{dxpy-0.402.0 → dxpy-0.404.0}/dxpy/nextflow/default_nextflow_instance_types.json

@@ -5,6 +5,7 @@
   "aws:me-south-1": "mem2_ssd1_v2_x4",
   "azure:westeurope": "azure:mem2_ssd1_x4",
   "azure:westus": "azure:mem2_ssd1_x4",
+  "azure:uksouth-ofh": "azure:mem2_ssd1_v2_x4",
   "aws:eu-west-2-g": "mem2_ssd1_v2_x4",
   "oci:us-ashburn-1": "oci:mem2_ssd1_v3i_x4"
 }

dxpy-0.404.0/dxpy/nextflow/nextaur_assets.json

@@ -0,0 +1,11 @@
+{
+    "aws:ap-southeast-2": "record-J5XQ90Q50QbxxqP4yF4JyxXf",
+    "aws:eu-central-1": "record-J5XQ908432kGV11kvkK73b0v",
+    "aws:eu-west-2-g": "record-J5XQ92XKJPJBJgj0byvp2qV1",
+    "aws:me-south-1": "record-J5XQ901386jgpGzp66zq4qVx",
+    "aws:us-east-1": "record-J5XQ5Bj0yYBJ6pGz3901JJ0g",
+    "azure:uksouth-ofh": "record-J5XQBV12vBB36yj477qXyb2X",
+    "azure:westeurope": "record-J5XQBQQByqk2pkk6GxVK996f",
+    "azure:westus": "record-J5XQG489v4kqvPPbqVpBBkvx",
+    "oci:us-ashburn-1": "record-J5XQ9Gk6Pgxp2jpKZvJfV781"
+}

dxpy-0.404.0/dxpy/nextflow/nextaur_assets.staging.json

@@ -0,0 +1,11 @@
+{
+    "aws:ap-southeast-2": "record-J5XPkB85vKPFvbFZ9YpXkGqG",
+    "aws:eu-central-1": "record-J5XPjyQ46yBGk8yJ74vJ21FZ",
+    "aws:eu-west-2-g": "record-J5XPj7XKfyYFvbFZ9YpXkGqB",
+    "aws:me-south-1": "record-J5XPjq93zvkxQX5kK6P57176",
+    "aws:us-east-1": "record-J5XPVJQ0xYgJP4FFG50239Bq",
+    "azure:uksouth-ofh": "record-J5XPpz92V3ZGk8yJ74vJ21Fk",
+    "azure:westeurope": "record-J5XPpvjBb99zGPPPBxP4pQQ1",
+    "azure:westus": "record-J5XPj689xYV7F14FQK7Q677f",
+    "oci:us-ashburn-1": "record-J5XPp8V66pvqvbFZ9YpXkGqK"
+}

{dxpy-0.402.0 → dxpy-0.404.0}/dxpy/nextflow/nextflow_assets.json

@@ -4,6 +4,7 @@
     "aws:eu-west-2-g": "record-GzyP8FXKkjkqfjBjjZzFv68F",
     "aws:me-south-1": "record-GzyP8593PgfZjYXPJP9FFqV4",
     "aws:us-east-1": "record-GzyP6X00F3gq8p88gP7PQFkx",
+    "azure:uksouth-ofh": "record-J5XVQjk272xZYBv0JK6JKxQ8",
     "azure:westeurope": "record-GzyPB98BB2b867v2KK1BXx8p",
     "azure:westus": "record-GzyPB6j9b5Yy81G8XV89jkZX",
     "oci:us-ashburn-1": "record-J30Z63V67qG7Y9ZfxjPpp90G"

{dxpy-0.402.0 → dxpy-0.404.0}/dxpy/nextflow/nextflow_assets.staging.json

@@ -4,6 +4,7 @@
     "aws:eu-west-2-g": "record-GzyJ2Z2KppXG1ZXvQ2kp08YQ",
     "aws:me-south-1": "record-GzyJ2Y93z3b2Q4202Jpx1j78",
     "aws:us-east-1": "record-GzyJ19j08Ffppvfvgx9bZzfz",
+    "azure:uksouth-ofh": "record-J5XV0Y92093xP4FFG50239K9",
     "azure:westeurope": "record-GzyJ4QjByJz29GJg3K3Gv2yB",
     "azure:westus": "record-GzyJ45Q9xQPB36YfkbQQxpp8",
     "oci:us-ashburn-1": "record-J30Xbb16kfQfgJqjXGf7561F"

{dxpy-0.402.0 → dxpy-0.404.0}/dxpy/scripts/dx.py

@@ -30,7 +30,7 @@ from ..compat import sys_encoding, basestring
 import dxpy
 from dxpy.scripts import dx_build_app
 from dxpy import workflow_builder
-from dxpy.exceptions import PermissionDenied, InvalidState, ResourceNotFound
+from dxpy.exceptions import PermissionDenied, InvalidState, ResourceNotFound, DXCLIError
 
 from ..cli import try_call, prompt_for_yn, INTERACTIVE_CLI
 from ..cli import workflow as workflow_cli
@@ -3191,27 +3191,39 @@ def run_body(args, executable, dest_proj, dest_path, preset_inputs=None, input_n
         # however when cloning from an analysis, the temporary workflow already has the cloned spec as its default, so no need to merge 1) and 2) here
         cloned_system_requirements = copy.deepcopy(args.cloned_job_desc).get("systemRequirements", {})
         cloned_instance_type = SystemRequirementsDict.from_sys_requirements(cloned_system_requirements, _type='instanceType')
+        cloned_instance_type_selector = SystemRequirementsDict.from_sys_requirements(cloned_system_requirements, _type='instanceTypeSelector')
         cloned_cluster_spec = SystemRequirementsDict.from_sys_requirements(cloned_system_requirements, _type='clusterSpec')
         cloned_fpga_driver = SystemRequirementsDict.from_sys_requirements(cloned_system_requirements, _type='fpgaDriver')
         cloned_nvidia_driver = SystemRequirementsDict.from_sys_requirements(cloned_system_requirements, _type='nvidiaDriver')
         cloned_system_requirements_by_executable = args.cloned_job_desc.get("mergedSystemRequirementsByExecutable", {}) or {}
     else:
         cloned_system_requirements = {}
-        cloned_instance_type, cloned_cluster_spec, cloned_fpga_driver, cloned_nvidia_driver = (
-            SystemRequirementsDict({}), SystemRequirementsDict({}), SystemRequirementsDict({}), SystemRequirementsDict({}))
+        cloned_instance_type, cloned_instance_type_selector, cloned_cluster_spec, cloned_fpga_driver, cloned_nvidia_driver = (
+            SystemRequirementsDict({}), SystemRequirementsDict({}), SystemRequirementsDict({}), SystemRequirementsDict({}), SystemRequirementsDict({}))
         cloned_system_requirements_by_executable = {}
 
     # convert runtime --instance-type into mapping {entrypoint:{'instanceType':xxx}}
     # here the args.instance_type no longer contains specifications for stage sys reqs
     if args.instance_type:
+        # Runtime --instance-type overrides instanceTypeSelector from the executable's runSpec
+        # When instanceType is specified at runtime, instanceTypeSelector should not be passed to the API
         requested_instance_type = SystemRequirementsDict.from_instance_type(args.instance_type)
         if not isinstance(args.instance_type, basestring):
             requested_instance_type = SystemRequirementsDict(merge(cloned_instance_type.as_dict(), requested_instance_type.as_dict()))
     else:
+        # If no runtime instanceType, use cloned instanceType (not instanceTypeSelector)
+        # instanceTypeSelector from the executable's runSpec will be resolved by the API
         requested_instance_type = cloned_instance_type
 
     # convert runtime --instance-count into mapping {entrypoint:{'clusterSpec':{'initialInstanceCount': N}}})
     if args.instance_count:
+        # Validate that we're not mixing clusterSpec with instanceTypeSelector
+        # clusterSpec and instanceTypeSelector are mutually exclusive at build time
+        # However, if instanceType is provided (either from runtime or cloned job), it overrides instanceTypeSelector
+        # So we only raise an error if instanceTypeSelector exists AND no instanceType override is present
+        if cloned_instance_type_selector.as_dict() and not requested_instance_type.as_dict():
+            raise DXCLIError("Cannot specify --instance-count when cloning a job that uses instanceTypeSelector "
+                            "without providing --instance-type. instanceTypeSelector and clusterSpec are mutually exclusive.")
         # retrieve the full cluster spec defined in executable's runSpec.systemRequirements
         # and overwrite the field initialInstanceCount with the runtime mapping
         requested_instance_count = SystemRequirementsDict.from_instance_count(args.instance_count)        
@@ -3232,8 +3244,11 @@ def run_body(args, executable, dest_proj, dest_path, preset_inputs=None, input_n
     requested_fpga_driver = cloned_fpga_driver
     requested_nvidia_driver = cloned_nvidia_driver
 
+
     # combine the requested instance type, full cluster spec, fpga spec, nvidia spec
     # into the runtime systemRequirements
+    # Note: instanceTypeSelector is NOT included here as it's build-time only
+    # If runtime instanceType was provided, it overrides instanceTypeSelector
     requested_system_requirements = (requested_instance_type + requested_cluster_spec + requested_fpga_driver +
                                      requested_nvidia_driver).as_dict()
 

{dxpy-0.402.0 → dxpy-0.404.0}/dxpy/system_requirements.py

@@ -83,9 +83,9 @@ class SystemRequirementsDict(object):
         """
         Returns SystemRequirementsDict encapsulating system requirements.
         It can extract only entrypoints with specific fields ('clusterSpec',
-        'instanceType', etc), depending on the value of _type.
+        'instanceType', 'instanceTypeSelector', etc), depending on the value of _type.
         """
-        allowed_types = ['all', 'clusterSpec', 'instanceType', 'fpgaDriver', 'nvidiaDriver']
+        allowed_types = ['all', 'clusterSpec', 'instanceType', 'instanceTypeSelector', 'fpgaDriver', 'nvidiaDriver']
         if _type not in (allowed_types):
             raise DXError("Expected '_type' to be one of the following: {}".format(allowed_types))
 

dxpy-0.404.0/dxpy/toolkit_version.py

@@ -0,0 +1 @@
+version = '0.404.0'

{dxpy-0.402.0 → dxpy-0.404.0}/dxpy.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: dxpy
-Version: 0.402.0
+Version: 0.404.0
 Summary: DNAnexus Platform API bindings for Python
 Home-page: https://github.com/dnanexus/dx-toolkit
 Author: Aleksandra Zalcman, Andrey Kislyuk, Anurag Biyani, Geet Duggal, Katherine Lai, Kurt Jensen, Marek Hrvol, Ohad Rodeh, Phil Sung

{dxpy-0.402.0 → dxpy-0.404.0}/test/test_dxclient.py

@@ -3280,6 +3280,46 @@ dx-jobutil-add-output record_array $second_record --array
         with self.assertSubprocessFailure(stderr_regexp='JSON', exit_code=3):
             run("dx run " + applet_id + " --extra-args not-a-JSON-string")
 
+    def test_dx_run_extra_args_instanceTypeSelector_rejected(self):
+        # Validate that instanceTypeSelector cannot be specified in runtime extra-args
+        applet_id = dxpy.api.applet_new({"project": self.project,
+                                         "dxapi": "1.0.0",
+                                         "runSpec": {"interpreter": "bash",
+                                                     "distribution": "Ubuntu",
+                                                     "release": "14.04",
+                                                     "code": "echo 'hello'"}
+                                         })['id']
+
+        # Test with wildcard entry point
+        with self.assertSubprocessFailure(stderr_regexp='instanceTypeSelector cannot be specified in runtime', exit_code=3):
+            run('dx run ' + applet_id + ' --extra-args ' +
+                '\'{"systemRequirements": {"*": {"instanceTypeSelector": {"allowedInstanceTypes": ["mem2_ssd1_v2_x2"]}}}}\'')
+
+        # Test with specific entry point
+        with self.assertSubprocessFailure(stderr_regexp='instanceTypeSelector cannot be specified in runtime', exit_code=3):
+            run('dx run ' + applet_id + ' --extra-args ' +
+                '\'{"systemRequirements": {"main": {"instanceTypeSelector": {"allowedInstanceTypes": ["mem2_ssd1_v2_x2"]}}}}\'')
+
+        # Test with regionalOptions
+        with self.assertSubprocessFailure(stderr_regexp='instanceTypeSelector cannot be specified in runtime', exit_code=3):
+            run('dx run ' + applet_id + ' --extra-args ' +
+                '\'{"regionalOptions": {"aws:us-east-1": {"systemRequirements": {"*": {"instanceTypeSelector": {"allowedInstanceTypes": ["mem2_ssd1_v2_x2"]}}}}}}\'')
+
+        # Test with systemRequirementsByExecutable
+        with self.assertSubprocessFailure(stderr_regexp='instanceTypeSelector cannot be specified in runtime', exit_code=3):
+            run('dx run ' + applet_id + ' --extra-args ' +
+                '\'{"systemRequirementsByExecutable": {"' + applet_id + '": {"main": {"instanceTypeSelector": {"allowedInstanceTypes": ["mem2_ssd1_v2_x2"]}}}}}\'')
+
+        # Test with systemRequirementsByExecutable with wildcard entry point
+        with self.assertSubprocessFailure(stderr_regexp='instanceTypeSelector cannot be specified in runtime', exit_code=3):
+            run('dx run ' + applet_id + ' --extra-args ' +
+                '\'{"systemRequirementsByExecutable": {"' + applet_id + '": {"*": {"instanceTypeSelector": {"allowedInstanceTypes": ["mem2_ssd1_v2_x2"]}}}}}\'')
+
+        # Test with regionalOptions.systemRequirementsByExecutable
+        with self.assertSubprocessFailure(stderr_regexp='instanceTypeSelector cannot be specified in runtime', exit_code=3):
+            run('dx run ' + applet_id + ' --extra-args ' +
+                '\'{"regionalOptions": {"aws:us-east-1": {"systemRequirementsByExecutable": {"' + applet_id + '": {"main": {"instanceTypeSelector": {"allowedInstanceTypes": ["mem2_ssd1_v2_x2"]}}}}}}}\'')
+
     def test_dx_run_sys_reqs(self):
         app_spec = {"project": self.project,
                     "dxapi": "1.0.0",
@@ -3378,6 +3418,73 @@ dx-jobutil-add-output record_array $second_record --array
         cloned_job_desc = dxpy.api.job_describe(cloned_job_id_nvidia_override)
         assert cloned_job_desc["systemRequirements"]["*"]["nvidiaDriver"] == build_nvidia_version
 
+    def test_dx_run_clone_with_instance_type_selector(self):
+        """
+        Test that when cloning a job from an applet that uses instanceTypeSelector:
+        1. Cloning without runtime args works - instanceTypeSelector is preserved
+        2. Cloning with --instance-type works - runtime instanceType overrides instanceTypeSelector
+        3. Cloning with --instance-count fails - clusterSpec and instanceTypeSelector are mutually exclusive
+        4. Job description contains instanceTypeSelector in systemRequirements
+        """
+        # Create an applet with instanceTypeSelector
+        applet_id = dxpy.api.applet_new({"project": self.project,
+                                         "dxapi": "1.0.0",
+                                         "runSpec": {"interpreter": "bash",
+                                                     "distribution": "Ubuntu",
+                                                     "release": "20.04",
+                                                     "version": "0",
+                                                     "code": "echo 'hello'",
+                                                     "systemRequirements": {
+                                                         "*": {
+                                                             "instanceTypeSelector": {
+                                                                 "allowedInstanceTypes": ["mem1_ssd1_x2", "mem2_ssd1_x2"]
+                                                             }
+                                                         }
+                                                     }}
+                                         })['id']
+
+        # Run the applet to create the origin job
+        # The API will resolve instanceTypeSelector to an actual instanceType
+        origin_job_id = run(f"dx run {applet_id} --brief -y").strip().split('\n')[-1]
+
+        # Verify the origin job description contains instanceTypeSelector
+        origin_job_desc = dxpy.api.job_describe(origin_job_id)
+        assert "systemRequirements" in origin_job_desc
+        assert "*" in origin_job_desc["systemRequirements"]
+        assert "instanceTypeSelector" in origin_job_desc["systemRequirements"]["*"]
+        assert "allowedInstanceTypes" in origin_job_desc["systemRequirements"]["*"]["instanceTypeSelector"]
+
+        # Clone without runtime args - should work, instanceTypeSelector is preserved
+        cloned_job_id_1 = run(f"dx run --clone {origin_job_id} --brief -y").strip()
+        assert cloned_job_id_1.startswith("job-")
+        cloned_job_desc_1 = dxpy.api.job_describe(cloned_job_id_1)
+        # Verify instanceTypeSelector is in the cloned job's systemRequirements
+        assert "instanceTypeSelector" in cloned_job_desc_1["systemRequirements"]["*"]
+
+        # Clone with --instance-type - should work, runtime instanceType overrides instanceTypeSelector
+        cloned_job_id_2 = run(f"dx run --clone {origin_job_id} --instance-type mem2_hdd2_x4 --brief -y").strip()
+        assert cloned_job_id_2.startswith("job-")
+        cloned_job_desc_2 = dxpy.api.job_describe(cloned_job_id_2)
+        # Verify instanceType is used instead of instanceTypeSelector
+        assert "instanceType" in cloned_job_desc_2["systemRequirements"]["*"]
+        assert cloned_job_desc_2["systemRequirements"]["*"]["instanceType"] == "mem2_hdd2_x4"
+        # instanceTypeSelector should not be in the runtime systemRequirements when overridden
+        # TODO uncomment later - for now this is not included in the backend behaviour
+        # assert "instanceTypeSelector" not in cloned_job_desc_2["systemRequirements"]["*"]
+
+        # Clone with --instance-count alone - should fail (clusterSpec and instanceTypeSelector are mutually exclusive)
+        with self.assertSubprocessFailure(stderr_regexp='Cannot specify --instance-count.*instanceTypeSelector.*without providing --instance-type', exit_code=3):
+            run(f"dx run --clone {origin_job_id} --instance-count 3 --brief -y")
+
+        # Clone with both --instance-count and --instance-type - should work (instanceType overrides instanceTypeSelector)
+        cloned_job_id_3 = run(f"dx run --clone {origin_job_id} --instance-count 3 --instance-type mem2_hdd2_x4 --brief -y").strip()
+        assert cloned_job_id_3.startswith("job-")
+        cloned_job_desc_3 = dxpy.api.job_describe(cloned_job_id_3)
+        # Verify instanceType override is applied
+        assert "instanceType" in cloned_job_desc_3["systemRequirements"]["*"]
+        assert cloned_job_desc_3["systemRequirements"]["*"]["instanceType"] == "mem2_hdd2_x4"
+        # Note: When the applet's runSpec doesn't have a clusterSpec defined (only instanceTypeSelector)
+
     def test_dx_run_clone(self):
         applet_id = dxpy.api.applet_new({"project": self.project,
                                          "dxapi": "1.0.0",