total-perspective-vortex 3.3.0__tar.gz → 3.3.1__tar.gz

{total_perspective_vortex-3.3.0 → total_perspective_vortex-3.3.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: total-perspective-vortex
-Version: 3.3.0
+Version: 3.3.1
 Summary: A library for routing entities (jobs, users or groups) to destinations in Galaxy
 Author: Galaxy Contributors
 Maintainer-email: Galaxy Committers <galaxy-committers@lists.galaxyproject.org>
@@ -63,12 +63,12 @@ GTN](https://training.galaxyproject.org/training-material/topics/admin/tutorials
 ### Installing latest released version
 
 Once configured in the Galaxy application, TPV will be automatically installed
-in the Galaxy environment. If you would like to manually install it instead, you
-can do so from [PyPI](https://pypi.org/project/total-perspective-vortex/) with
+in the Galaxy environment. If you would like to manually install it for independent
+CLI use instead, you can do so from [PyPI](https://pypi.org/project/total-perspective-vortex/) with
 the following command:
 
 ```python
-pip install total-perspective-vortex
+pip install "total-perspective-vortex[cli]"
 ```
 
 

{total_perspective_vortex-3.3.0 → total_perspective_vortex-3.3.1}/README.md

@@ -23,12 +23,12 @@ GTN](https://training.galaxyproject.org/training-material/topics/admin/tutorials
 ### Installing latest released version
 
 Once configured in the Galaxy application, TPV will be automatically installed
-in the Galaxy environment. If you would like to manually install it instead, you
-can do so from [PyPI](https://pypi.org/project/total-perspective-vortex/) with
+in the Galaxy environment. If you would like to manually install it for independent
+CLI use instead, you can do so from [PyPI](https://pypi.org/project/total-perspective-vortex/) with
 the following command:
 
 ```python
-pip install total-perspective-vortex
+pip install "total-perspective-vortex[cli]"
 ```
 
 

{total_perspective_vortex-3.3.0 → total_perspective_vortex-3.3.1}/pyproject.toml

@@ -14,7 +14,7 @@ authors = [
 maintainers = [
     {name = "Galaxy Committers", email = "galaxy-committers@lists.galaxyproject.org"}
 ]
-version = "3.3.0"
+version = "3.3.1"
 dependencies = [
     "pydantic>=2",
     "cachetools>=3.1.0",

{total_perspective_vortex-3.3.0 → total_perspective_vortex-3.3.1}/tests/test_entity.py

@@ -11,6 +11,53 @@ from tpv.rules import gateway
 
 class TestEntity(unittest.TestCase):
 
+    def test_rule_context_uses_local_copy_and_keeps_self_alias(self):
+        loader = TPVConfigLoader(
+            {
+                "tools": {
+                    "test": {
+                        "cores": 1,
+                        "params": {},
+                        "rules": [
+                            {
+                                "if": "self is entity and entity.cores == 1",
+                                "execute": "entity.params['local_change'] = 'preserved'",
+                            },
+                            {"if": True, "cores": 4},
+                            {
+                                "if": "self is entity and entity.cores == 4",
+                                "execute": "entity.mem = 8",
+                            },
+                        ],
+                    }
+                }
+            }
+        )
+        original = loader.config.tools["test"]
+        context = {"entity": original, "self": original}
+        evaluated = original.evaluate_rules(context)
+        self.assertEqual(evaluated.cores, 4)
+        self.assertEqual(evaluated.mem, 8)
+        self.assertEqual(evaluated.params, {"local_change": "preserved"})
+        self.assertEqual(original.cores, 1)
+        self.assertIsNone(original.mem)
+        self.assertEqual(original.params, {})
+        self.assertIs(context["entity"], evaluated)
+        self.assertIs(context["self"], evaluated)
+        self.assertIsNot(evaluated, original)
+
+    def test_rule_context_initialized_when_no_rules_match(self):
+        for rules in ([], [{"if": False, "cores": 4}]):
+            with self.subTest(rules=rules):
+                loader = TPVConfigLoader({"tools": {"test": {"cores": 1, "rules": rules}}})
+                original = loader.config.tools["test"]
+                context = {}
+                evaluated = original.evaluate_rules(context)
+                self.assertIs(context["entity"], evaluated)
+                self.assertIs(context["self"], evaluated)
+                self.assertIsNot(evaluated, original)
+                self.assertEqual(evaluated.cores, 1)
+
     @staticmethod
     def _map_to_destination(app, job, tool, user, referrer=None):
         tpv_config = os.path.join(os.path.dirname(__file__), "fixtures/mapping-rule-argument-based.yml")

{total_perspective_vortex-3.3.0 → total_perspective_vortex-3.3.1}/tests/test_explain.py

@@ -242,6 +242,20 @@ class TestDryRunExplain(unittest.TestCase):
         self.assertIn("Destination Ranking", trace)
         self.assertIn("Final Result", trace)
 
+    def test_dry_run_explain_unconfigured_tool_without_a_default(self):
+        """A tool with no entity in a config that sets no default_inherits still maps, via the
+        entity TPV builds from the Galaxy tool itself -- and the trace names that entity, which is
+        how an admin learns the tool got injected defaults rather than configured ones."""
+        dry_runner = TPVDryRunner.from_params(
+            job_conf=self._fixture_path("job_conf_dry_run.yml"),
+            tool_id="a_tool_nobody_configured",
+            user_email="fairycake@vortex.org",
+            tpv_confs=[self._fixture_path("mapping-inheritance-no-default.yml")],
+        )
+        destination, collector = dry_runner.run(explain=True)
+        self.assertIsNotNone(destination)
+        self.assertIn("matched entity 'tool_provided_resources_a_tool_nobody_configured'", collector.render())
+
     def test_dry_run_explain_shows_matched_entities(self):
         """The trace should show which tool and user entities matched."""
         dry_runner = TPVDryRunner.from_params(
@@ -501,7 +515,6 @@ class TestDryRunExplain(unittest.TestCase):
         self.assertIsNone(runner.tool)
 
 
-
 class TestGatewayExplainOnFailure(unittest.TestCase):
     """Tests for the tpv_explain_on_failure gateway config option."""
 
@@ -516,7 +529,10 @@ class TestGatewayExplainOnFailure(unittest.TestCase):
         job = mock_galaxy.Job()
         user = mock_galaxy.User("gargravarr", "fairycake@vortex.org")
         return gateway.map_tool_to_destination(
-            app, job, tool, user,
+            app,
+            job,
+            tool,
+            user,
             referrer=referrer,
             tpv_config_files=[self._fixture_path("mapping-basic.yml")],
             explain_collector=explain_collector,

{total_perspective_vortex-3.3.0 → total_perspective_vortex-3.3.1}/tests/test_helpers.py

@@ -6,11 +6,15 @@ from unittest.mock import patch
 
 from tpv.commands.test import mock_galaxy
 from tpv.core.helpers import (
+    concurrent_job_count_for_tool,
     get_dataset_attributes,
     get_input_dataset,
     get_input_datasets,
     get_input_size,
     input_size,
+    job_args_match,
+    tool_version_eq,
+    tool_version_gte,
     weighted_choice,
     weighted_random_sampling,
 )
@@ -97,6 +101,13 @@ class TestHelpers(unittest.TestCase):
         # the existing input_size helper deduplicates the same way
         self.assertEqual(input_size(job), 8)
 
+    def test_get_input_size_skips_inputs_whose_dataset_is_gone(self):
+        # An input association can outlive its dataset (deleted or purged). It must contribute
+        # nothing rather than raise mid-scheduling.
+        job = self._job_with_multiple_data_param()
+        job.add_input_dataset(mock_galaxy.DatasetAssociation("gone", None))
+        self.assertEqual(get_input_size(job), 8)
+
     def test_get_input_size_by_param_name(self):
         job = self._job_with_multiple_data_param()
         job.add_input_dataset(
@@ -263,3 +274,77 @@ class TestHelpers(unittest.TestCase):
 
         self.assertIsInstance(result, dict)
         self.assertEqual(result, items[1])
+
+
+class TestJobArgsMatch(unittest.TestCase):
+    """job_args_match decides whether a rule fires on a job's parameters. Its only test so far is
+    the positive case, which a helper that always returned True would pass."""
+
+    def setUp(self):
+        self.app = mock_galaxy.App(create_model=True)
+        self.job = mock_galaxy.Job()
+        self.job.param_values = {
+            "input_opts": {"db_selector": "db", "tabs_to_spaces": False},
+            "files": [{"name": "reads.fq"}],
+        }
+
+    def test_matches_only_when_every_given_value_matches(self):
+        self.assertTrue(job_args_match(self.job, self.app, {"input_opts": {"db_selector": "db"}}))
+        self.assertFalse(job_args_match(self.job, self.app, {"input_opts": {"db_selector": "other"}}))
+        # one matching and one differing value is not a match
+        self.assertFalse(
+            job_args_match(self.job, self.app, {"input_opts": {"db_selector": "db", "tabs_to_spaces": True}})
+        )
+
+    def test_a_parameter_the_job_does_not_have_does_not_match(self):
+        self.assertFalse(job_args_match(self.job, self.app, {"input_opts": {"no_such_option": 1}}))
+        self.assertFalse(job_args_match(self.job, self.app, {"no_such_section": {"x": 1}}))
+        # a nested dict in args where the job's parameter is a scalar is a mismatch, not an error
+        self.assertFalse(job_args_match(self.job, self.app, {"files": {"name": "reads.fq"}}))
+
+    def test_nothing_to_match_against_never_matches(self):
+        for args in (None, {}, "input_opts", ["input_opts"]):
+            with self.subTest(args=args):
+                self.assertFalse(job_args_match(self.job, self.app, args))
+
+    def test_a_list_valued_parameter_is_compared_as_a_whole(self):
+        # Repeats and multi-selects are lists. The list is the value; keys inside its items are
+        # not a path into it.
+        self.assertTrue(job_args_match(self.job, self.app, {"files": [{"name": "reads.fq"}]}))
+        self.assertFalse(job_args_match(self.job, self.app, {"files": [{"name": "other.fq"}]}))
+
+
+class TestConcurrentJobCount(unittest.TestCase):
+    def test_plain_tool_ids_match_exactly_and_do_not_count_prefix_collisions(self):
+        # Tool Shed ids are matched by prefix so every installed version is counted together.
+        # A plain id must not get that treatment: "bwa" must not count "bwa_mem" jobs.
+        app = mock_galaxy.App(create_model=True)
+        session = app.model.context
+        user = app.model.User(username="arthur", email="arthur@vortex.org", password="x")
+        session.add(user)
+        session.flush()
+        for tool_id in ("bwa", "bwa", "bwa_mem"):
+            job = app.model.Job()
+            job.user = user
+            job.tool_id = tool_id
+            job.state = "running"
+            session.add(job)
+        session.flush()
+
+        self.assertEqual(concurrent_job_count_for_tool(app, mock_galaxy.Tool("bwa")), 2)
+        self.assertEqual(concurrent_job_count_for_tool(app, mock_galaxy.Tool("bwa_mem")), 1)
+
+
+class TestToolVersionComparison(unittest.TestCase):
+    def test_versions_are_compared_as_versions_not_strings(self):
+        tool = mock_galaxy.Tool("t", version="1.2.0")
+        self.assertTrue(tool_version_eq(tool, "1.2"))  # PEP 440: 1.2.0 == 1.2
+        self.assertTrue(tool_version_eq(tool, "1.2.0"))
+        self.assertFalse(tool_version_eq(tool, "1.3"))
+        self.assertTrue(tool_version_gte(tool, "1.10") is False)  # not a string compare: "1.2" < "1.10"
+
+    def test_comparison_is_unknown_not_false_when_a_version_is_missing(self):
+        # A rule can tell "no version to compare" (None) from "compared and did not match" (False).
+        unversioned = mock_galaxy.Tool("t")
+        self.assertIsNone(tool_version_eq(unversioned, "1.0"))
+        self.assertIsNone(tool_version_gte(mock_galaxy.Tool("t", version="1.0"), None))

{total_perspective_vortex-3.3.0 → total_perspective_vortex-3.3.1}/tests/test_mapper_resource_requirements.py

@@ -40,6 +40,13 @@ class TestMapperResourceRequirements(unittest.TestCase):
         result = extract_resource_requirements_from_tool(tool)
         self.assertEqual(result, {})
 
+    def test_requirement_types_tpv_does_not_map_are_ignored(self):
+        # Tools may declare tmpdir_min, outdir_min etc. TPV maps only cores and RAM; the rest must
+        # be skipped, not fail the tool.
+        reqs = [ResourceRequirement("4", "cores_min"), ResourceRequirement("10", "tmpdir_min")]
+        tool = mock_galaxy.Tool("test_tool", resource_requirements=reqs)
+        self.assertEqual(extract_resource_requirements_from_tool(tool), {"cores": 4})
+
     def test_extract_resource_requirements_from_tool_cores(self):
         cores_req = ResourceRequirement("4", "cores_min")
 

{total_perspective_vortex-3.3.0 → total_perspective_vortex-3.3.1}/tests/test_mapper_rules.py

@@ -8,11 +8,45 @@ from galaxy.jobs import JobDestination
 from galaxy.jobs.mapper import JobMappingException, JobNotReadyException
 
 from tpv.commands.test import mock_galaxy
+from tpv.core.entities import TryNextDestinationOrFail, TryNextDestinationOrWait
+from tpv.core.loader import TPVConfigLoader
+from tpv.core.mapper import EntityToDestinationMapper
 from tpv.rules import gateway
 
 
 class TestMapperRules(unittest.TestCase):
 
+    def _destination_context_mapper(self):
+        config = os.path.join(os.path.dirname(__file__), "fixtures/mapping-destination-context.yml")
+        return EntityToDestinationMapper(TPVConfigLoader.from_url_or_path(config))
+
+    def _map_destination_context(self, mapper):
+        app = mock_galaxy.App(job_conf=os.path.join(os.path.dirname(__file__), "fixtures/job_conf.yml"))
+        return mapper.map_to_destination(app, mock_galaxy.Tool("test"), None, mock_galaxy.Job())
+
+    def test_first_destination_rule_condition_sees_combined_destination(self):
+        mapper = self._destination_context_mapper()
+        destination = self._map_destination_context(mapper)
+        self.assertEqual(destination.id, "condor")
+        self.assertEqual(destination.params["inspected_destination"], "condor")
+        self.assertEqual(mapper.global_context["attempts"], ["condor"])
+
+    def test_first_destination_rule_execute_sees_combined_destination(self):
+        mapper = self._destination_context_mapper()
+        mapper.destinations["condor"].rules["inspect_destination"].if_condition = True
+        destination = self._map_destination_context(mapper)
+        self.assertEqual(destination.params["inspected_destination"], "condor")
+
+    def test_destination_fallback_refreshes_rule_context(self):
+        for rejection in (TryNextDestinationOrFail, TryNextDestinationOrWait):
+            with self.subTest(rejection=rejection.__name__):
+                mapper = self._destination_context_mapper()
+                mapper.global_context["rejection"] = rejection
+                destination = self._map_destination_context(mapper)
+                self.assertEqual(destination.id, "fallback")
+                self.assertEqual(destination.params["inspected_destination"], "fallback")
+                self.assertEqual(mapper.global_context["attempts"], ["condor", "fallback"])
+
     @staticmethod
     def _map_to_destination(
         tool,
@@ -128,6 +162,31 @@ class TestMapperRules(unittest.TestCase):
                 ["8"],
             )
 
+    def test_invalid_edit_keeps_the_previous_rules_active(self):
+        """Hot reload must not take scheduling down on a bad edit: if the rewritten file fails to
+        load, the previously loaded rules stay in force and the failure is logged."""
+        with tempfile.NamedTemporaryFile("w+t") as tmp_file:
+            shutil.copy2(os.path.join(os.path.dirname(__file__), "fixtures/mapping-rules.yml"), tmp_file.name)
+            tool = mock_galaxy.Tool("bwa")
+            user = mock_galaxy.User("gargravarr", "fairycake@vortex.org")
+            datasets = [mock_galaxy.DatasetAssociation("test", mock_galaxy.Dataset("test.txt", file_size=5 * 1024**3))]
+
+            destination = self._map_to_destination(
+                tool, user, datasets, tpv_config_files=[tmp_file.name], reset_mappers=True
+            )
+            self.assertEqual([e["value"] for e in destination.env if e["name"] == "TEST_JOB_SLOTS_USER"], ["4"])
+
+            with open(tmp_file.name, "w") as f:
+                f.write("tools:\n  default:\n    cores: [this is not valid config\n")
+            with self.assertLogs("tpv.rules.gateway", level="WARNING") as logs:
+                time.sleep(2)  # wait for the watcher to attempt the reload
+            self.assertTrue(any("Failed to reload" in line for line in logs.output), logs.output)
+
+            destination = self._map_to_destination(
+                tool, user, datasets, tpv_config_files=[tmp_file.name], reset_mappers=False
+            )
+            self.assertEqual([e["value"] for e in destination.env if e["name"] == "TEST_JOB_SLOTS_USER"], ["4"])
+
     def test_multiple_files_automatically_reload_on_update(self):
         with tempfile.NamedTemporaryFile("w+t") as tmp_file1, tempfile.NamedTemporaryFile("w+t") as tmp_file2:
             rule_file = os.path.join(os.path.dirname(__file__), "fixtures/mapping-rules.yml")

{total_perspective_vortex-3.3.0 → total_perspective_vortex-3.3.1}/tests/test_resource_pool.py

@@ -182,6 +182,16 @@ class TestStoreConfig(unittest.TestCase):
         self.assertEqual(StoreConfig().store_class, "tpv.core.resource_pool.ValkeyAllocationStore")
 
 
+class TestStoreConfigErrors(unittest.TestCase):
+    def test_bare_class_name_is_rejected_with_a_clear_message(self):
+        from tpv.core.resource_pool import StoreConfig
+
+        # `class: InMemoryAllocationStore` (no module) is the likely typo; it must fail loudly at
+        # load, naming the problem, rather than with an AttributeError deep in importlib.
+        with self.assertRaisesRegex(ValueError, "dotted class path"):
+            StoreConfig.model_validate({"class": "InMemoryAllocationStore"}).build_store()
+
+
 class TestTerminalJobIds(unittest.TestCase):
     def test_returns_only_terminal_jobs(self):
         app = mock_galaxy.App(create_model=True)
@@ -589,6 +599,131 @@ class TestResourcePoolBranches(unittest.TestCase):
             EntityToDestinationMapper(loader)
 
 
+class TestValkeyStoreBackendErrors(unittest.TestCase):
+    """Fail-closed rests on the adapter turning backend errors into StoreUnavailable, which the
+    mapper turns into deferral. Every other fail-closed test raises StoreUnavailable directly;
+    this one drives real redis exceptions through the adapter, so the translation itself is
+    what is under test."""
+
+    @staticmethod
+    def _store_whose_backend_raises(error):
+        class Client:
+            def hgetall(self, key):
+                raise error
+
+            def register_script(self, script):
+                def run(keys, args):
+                    raise error
+
+                return run
+
+        return ValkeyAllocationStore(client=Client())
+
+    @staticmethod
+    def _admission():
+        return PoolAdmission("p", ResourceUsage(1, 0, 0), NORMAL, Budget(), 0, False, set())
+
+    def test_redis_errors_become_store_unavailable(self):
+        import redis
+
+        for error in (redis.exceptions.ConnectionError("refused"), redis.exceptions.TimeoutError("slow")):
+            with self.subTest(error=type(error).__name__):
+                store = self._store_whose_backend_raises(error)
+                with self.assertRaises(StoreUnavailable):
+                    store.read("p", 1)
+                with self.assertRaises(StoreUnavailable):
+                    store.admit_many(1, 1, [self._admission()])
+
+    def test_other_errors_are_not_reported_as_an_outage(self):
+        # A bug in our own code must surface as itself. Reporting it as "store unavailable" would
+        # silently defer every governed job with a misleading warning.
+        store = self._store_whose_backend_raises(TypeError("bug"))
+        with self.assertRaises(TypeError):
+            store.read("p", 1)
+        with self.assertRaises(TypeError):
+            store.admit_many(1, 1, [self._admission()])
+
+    def test_valkey_url_schemes_map_to_the_redis_schemes_redis_py_understands(self):
+        import redis
+
+        cases = [
+            ("valkey://host:6379/0", "redis://host:6379/0"),
+            ("valkeys://host:6379/0", "rediss://host:6379/0"),  # TLS
+            ("redis://host:6379/0", "redis://host:6379/0"),
+        ]
+        for given, expected in cases:
+            with self.subTest(url=given), patch.object(redis, "from_url") as from_url:
+                ValkeyAllocationStore(url=given)
+                self.assertEqual(from_url.call_args.args[0], expected)
+
+
+class TestResourcePoolExplain(unittest.TestCase):
+    """The explain trace is how an operator finds out why a job is stuck. The happy path and
+    permanent rejection are covered by the dry-run tests; these pin the messages for the
+    outcomes that actually leave a job waiting -- a full pool and a store outage -- and that the
+    fail_open variant says so rather than looking like a normal admission."""
+
+    def _mapper(self):
+        return EntityToDestinationMapper(TPVConfigLoader.from_url_or_path(FIXTURE))
+
+    @staticmethod
+    def _job(job_id):
+        job = mock_galaxy.Job()
+        job.id = job_id
+        return job
+
+    def _trace(self, mapper, tool, expect=None):
+        from tpv.core.explain import ExplainCollector
+
+        collector = ExplainCollector()
+        user = mock_galaxy.User("arthur", "arthur@vortex.org", id=1)
+        call = lambda: mapper.map_to_destination(  # noqa: E731
+            mock_galaxy.App(create_model=True), mock_galaxy.Tool(tool), user, self._job(1), explain_collector=collector
+        )
+        if expect is None:
+            call()
+        else:
+            with self.assertRaises(expect):
+                call()
+        return collector.render()
+
+    def test_deferral_names_the_full_pool(self):
+        mapper = self._mapper()
+        _seed(mapper.resource_pools.store, "default", 1, 900, ResourceUsage(30, 0, 0))
+        trace = self._trace(mapper, "default", expect=JobNotReadyException)
+        self.assertIn("DEFERRED", trace)
+        self.assertIn("default", trace)
+
+    def test_store_outage_is_reported_with_the_policy_that_decided_it(self):
+        for fail_open, expect, message in (
+            (False, JobNotReadyException, "fail-closed -> deferred"),
+            (True, None, "fail_open -> admitted"),
+        ):
+            with self.subTest(fail_open=fail_open):
+                mapper = self._mapper()
+                mapper.resource_pools.store = _RaisingStore()
+                mapper.pools["default"].fail_open = fail_open
+                trace = self._trace(mapper, "default", expect=expect)
+                self.assertIn("store unavailable", trace)
+                self.assertIn(message, trace)
+
+    def test_outage_during_the_batch_write_is_reported(self):
+        # The read succeeded and every pool resolved; the single atomic write then failed. The
+        # trace must say the store was the problem, not that the pool was full.
+        for all_fail_open, expect, message in (
+            (False, JobNotReadyException, "fail-closed -> deferred"),
+            (True, None, "every pool is fail_open -> admitted"),
+        ):
+            with self.subTest(all_fail_open=all_fail_open):
+                mapper = self._mapper()
+                mapper.pools["default"].fail_open = all_fail_open
+                with patch.object(mapper.resource_pools.store, "admit_many", side_effect=StoreUnavailable("down")):
+                    trace = self._trace(mapper, "default", expect=expect)
+                self.assertIn("Store unavailable", trace)
+                self.assertIn(message, trace)
+                self.assertNotIn("DEFERRED: user", trace)
+
+
 def _build_valkey_store():
     """A ValkeyAllocationStore backed by fakeredis, or None when fakeredis+Lua is unavailable.
 
@@ -669,6 +804,10 @@ PARITY_SCENARIOS = {
         _op(1, ResourceUsage(64, 0, 0), kind=OVERSIZE, max_oversize=1, reserve_pool=True),
         _op(2, ResourceUsage(1, 0, 0), kind=NORMAL, max_oversize=1, reserve_pool=True),
     ],
+    "reserve_pool_blocks_oversize_while_normal_runs": [
+        _op(1, ResourceUsage(1, 0, 0), kind=NORMAL, max_oversize=1, reserve_pool=True),
+        _op(2, ResourceUsage(64, 0, 0), kind=OVERSIZE, max_oversize=1, reserve_pool=True),
+    ],
     "drop_releases": [_op(1, ResourceUsage(30, 0, 0)), _op(2, ResourceUsage(8, 0, 0), drop=(1,))],
 }
 

{total_perspective_vortex-3.3.0 → total_perspective_vortex-3.3.1}/tests/test_shell.py

@@ -152,6 +152,13 @@ class TPVShellTestCase(unittest.TestCase):
             f"Expected Name 'mem2' is not defined but output was: {output}",
         )
 
+    def test_lint_types_checks_role_rules(self):
+        # Every other type-check test puts the bad expression on a tool. A regression that skipped
+        # roles when gathering code blocks would leave role rules unchecked and pass those tests.
+        tpv_config = os.path.join(os.path.dirname(__file__), "fixtures/linter/linter-types-role-rule.yml")
+        output = self.call_shell_command("tpv", "-vv", "lint", tpv_config)
+        self.assertIn('error: Name "training_quota_exceeded" is not defined', output, output)
+
     def test_lint_types_legacy_tagset_reference(self):
         tpv_config = os.path.join(
             os.path.dirname(__file__),
@@ -773,6 +780,14 @@ class TPVShellTestCase(unittest.TestCase):
         self.assertIn("bwa:", output)
         self.assertIn("local:", output)
 
+    def test_dump_includes_resource_pools(self):
+        # dump is how an admin inspects the merged config; pools are a top-level section like tools.
+        tpv_config = os.path.join(os.path.dirname(__file__), "fixtures/mapping-resource-pool.yml")
+        output = self.call_shell_command("tpv", "dump", tpv_config)
+        self.assertIn("--- Pools ---", output, output)
+        self.assertIn("gpu:", output)
+        self.assertIn("max_concurrent_gpus", output)
+
     def test_dump_multiple_configs(self):
         remote = os.path.join(os.path.dirname(__file__), "fixtures/mapping-merge-multiple-remote.yml")
         local = os.path.join(os.path.dirname(__file__), "fixtures/mapping-merge-multiple-local.yml")

{total_perspective_vortex-3.3.0 → total_perspective_vortex-3.3.1}/total_perspective_vortex.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: total-perspective-vortex
-Version: 3.3.0
+Version: 3.3.1
 Summary: A library for routing entities (jobs, users or groups) to destinations in Galaxy
 Author: Galaxy Contributors
 Maintainer-email: Galaxy Committers <galaxy-committers@lists.galaxyproject.org>
@@ -63,12 +63,12 @@ GTN](https://training.galaxyproject.org/training-material/topics/admin/tutorials
 ### Installing latest released version
 
 Once configured in the Galaxy application, TPV will be automatically installed
-in the Galaxy environment. If you would like to manually install it instead, you
-can do so from [PyPI](https://pypi.org/project/total-perspective-vortex/) with
+in the Galaxy environment. If you would like to manually install it for independent
+CLI use instead, you can do so from [PyPI](https://pypi.org/project/total-perspective-vortex/) with
 the following command:
 
 ```python
-pip install total-perspective-vortex
+pip install "total-perspective-vortex[cli]"
 ```
 
 

{total_perspective_vortex-3.3.0 → total_perspective_vortex-3.3.1}/tpv/core/entities.py

@@ -565,6 +565,8 @@ class EntityWithRules(Entity):
     def evaluate_rules(self, context: dict[str, Any]) -> Self:
         new_entity = copy.deepcopy(self)
         context.update(new_entity.context or {})
+        # Conditions and execute blocks must see the local entity, including for each destination candidate.
+        context.update({"entity": new_entity, "self": new_entity})
         explain = ExplainCollector.from_context(context)
         for rule in self.rules.values():
             if rule.is_matching(context):
@@ -590,7 +592,7 @@ class EntityWithRules(Entity):
                 new_entity.cores = rule.cores or new_entity.cores
                 new_entity.mem = rule.mem or new_entity.mem
                 new_entity.id = f"{new_entity.id}, Rule: {rule.id}"
-                context.update({"entity": new_entity})
+                context.update({"entity": new_entity, "self": new_entity})
             else:
                 if explain:
                     explain.add_step(

{total_perspective_vortex-3.3.0 → total_perspective_vortex-3.3.1}/tpv/core/helpers.py

@@ -123,7 +123,9 @@ def get_input_size(
     """
     total = 0.0
     for dataset in get_input_datasets(job, param_name):
-        if not dataset.dataset:
+        # get_input_datasets already drops associations without a dataset; this narrows the
+        # Optional type for mypy and cannot run.
+        if not dataset.dataset:  # pragma: no cover
             continue
         multiplier = 1.0
         if estimate_uncompressed_size and (dataset.extension or "").endswith(COMPRESSED_EXTENSION_SUFFIXES):
@@ -166,38 +168,24 @@ def weighted_choice(items: list[WeightedT]) -> WeightedT:
     return _weighted_draw(items, [item.get("weight", 1) for item in items], k=1)[0]
 
 
-def __get_keys_from_dict(dl: Any, keys_list: list[str]) -> None:
-    # This function builds a list using the keys from nested dictionaries
-    # (copied from galaxyproject/galaxy lib/galaxy/jobs/dynamic_tool_destination.py)
-    if isinstance(dl, dict):
-        keys_list.extend(dl.keys())
-        for x in dl.values():
-            __get_keys_from_dict(x, keys_list)
-    elif isinstance(dl, list):
-        for x in dl:
-            __get_keys_from_dict(x, keys_list)
+def __args_match(args: Any, params: Any) -> bool:
+    # Every key in `args` must be present in `params`, recursing through nested dicts. Anything
+    # that is not a dict -- scalars and lists alike -- is a leaf and must compare equal, so a
+    # list-valued parameter (a repeat or multi-select) is matched as a whole.
+    if isinstance(args, dict):
+        if not isinstance(params, dict):
+            return False
+        return all(key in params and __args_match(value, params[key]) for key, value in args.items())
+    return bool(args == params)
 
 
 def job_args_match(job: Job, app: UniverseApplication, args: dict[str, Any] | None) -> bool:
-    # Check whether a dictionary of arguments matches a job's parameters.  This code is
-    # from galaxyproject/galaxy lib/galaxy/jobs/dynamic_tool_destination.py
+    """Whether every argument in ``args`` matches the job's parameters, e.g.
+    ``{'input_opts': {'db_selector': 'db'}}`` matches a job whose ``input_opts|db_selector`` is
+    ``db``. Nested dicts are matched key by key; lists and scalars must be equal."""
     if not args or not isinstance(args, dict):
         return False
-    options = job.get_param_values(app)  # type: ignore[no-untyped-call]
-    matched = True
-    # check if the args in the config file are available
-    for arg in args:
-        arg_dict = {arg: args[arg]}
-        arg_keys_list: list[str] = []
-        __get_keys_from_dict(arg_dict, arg_keys_list)
-        try:
-            options_value = reduce(dict.__getitem__, arg_keys_list, options)
-            arg_value = reduce(dict.__getitem__, arg_keys_list, arg_dict)
-            if arg_value != options_value:
-                matched = False
-        except KeyError:
-            matched = False
-    return matched
+    return __args_match(args, job.get_param_values(app))  # type: ignore[no-untyped-call]
 
 
 def concurrent_job_count_for_tool(

{total_perspective_vortex-3.3.0 → total_perspective_vortex-3.3.1}/tpv/core/mapper.py

@@ -171,10 +171,10 @@ class EntityToDestinationMapper(object):
     def __apply_default_destination_inheritance(
         self, entity_list: dict[str, Destination], context: Mapping[str, Any]
     ) -> list[Destination]:
+        # Never empty: _get_common_inherits always contributes the tool_type_secure_defaults
+        # destination, so every destination inherits at least that.
         inherited_defaults = self._get_common_inherits(context, entity_list, Destination)
-        if inherited_defaults:
-            return [self.inherit_entities([*inherited_defaults, entity]) for entity in entity_list.values()]
-        return list(entity_list.values())
+        return [self.inherit_entities([*inherited_defaults, entity]) for entity in entity_list.values()]
 
     def inherit_entities(self, entities: list[EntityType]) -> EntityType:
         return functools.reduce(lambda a, b: b.inherit(a), entities)
@@ -270,21 +270,15 @@ class EntityToDestinationMapper(object):
             tool_id = f"{tool.tool_type}-{tool.dynamic_tool.uuid}"
         else:
             tool_id = tool.id or "unknown_tool_id"
+        # Never None: _get_common_inherits always contributes the tool_provided_resources entity
+        # built from the Galaxy tool itself, so an unconfigured tool still resolves to an entity.
         tool_entity = self.inherit_matching_entities(context, Tool, "tools", tool_id)
-
-        if not tool_entity:
-            tool_entity = Tool(evaluator=self.loader, id=tool_id)
-            if explain:
-                explain.add_step(
-                    ExplainPhase.ENTITY_MATCHING,
-                    f"Tool '{tool_id}': no explicit match, using default",
-                )
-        else:
-            if explain:
-                explain.add_step(
-                    ExplainPhase.ENTITY_MATCHING,
-                    f"Tool '{tool_id}': matched entity '{tool_entity.id}'",
-                )
+        assert tool_entity is not None
+        if explain:
+            explain.add_step(
+                ExplainPhase.ENTITY_MATCHING,
+                f"Tool '{tool_id}': matched entity '{tool_entity.id}'",
+            )
 
         entity_list: list[EntityWithRules] = [tool_entity]