Fix type bug in build_trackers -- skip non-callable modules

Summary:
Fix ``build_trackers()`` in ``tracker/api.py`` to skip non-callable modules
returned by ``load_module()``. Previously, ``ModuleType`` objects were being
passed where callables were expected, causing ``TypeError: 'module' object
is not callable`` at runtime.

**Root cause:** ``load_module()`` returns ``types.ModuleType`` for packages
(directories with ``__init__.py``) but ``build_trackers()`` assumed all
return values were factory callables.

**Fix:** Added ``callable()`` guard before invoking the loaded object.
Non-callable modules are silently skipped with a debug log message.

**Cleanup:** Removed unused ``source_data`` variable in test MockTracker.

Differential Revision: D95932184

Author: kiukchung

torchx/tracker/api.py

@@ -155,16 +155,26 @@ def build_trackers(
         logger.warning("No 'torchx.tracker' entry_points are defined.")
 
     for factory_name, config in factory_and_config.items():
-        factory = entrypoint_factories.get(factory_name) or load_module(factory_name)
-        if not factory:
+        resolved = entrypoint_factories.get(factory_name) or load_module(factory_name)
+        if not resolved:
             logger.warning(
-                f"No tracker factory `{factory_name}` found in entry_points or modules. See https://meta-pytorch.org/torchx/main/tracker.html#module-torchx.tracker"
+                "no tracker factory `%s` found in entry_points or modules."
+                " See https://meta-pytorch.org/torchx/main/tracker.html#module-torchx.tracker",
+                factory_name,
             )
             continue
+        if not callable(resolved):
+            logger.warning(
+                "tracker factory `%s` resolved to a module, not a callable."
+                " Use `module.path:factory_function` syntax to specify the factory",
+                factory_name,
+            )
+            continue
+        factory = resolved
         if config:
-            logger.info(f"Tracker config found for `{factory_name}` as `{config}`")
+            logger.info("tracker config found for `%s` as `%s`", factory_name, config)
         else:
-            logger.info(f"No tracker config specified for `{factory_name}`")
+            logger.info("no tracker config specified for `%s`", factory_name)
         tracker = factory(config)
         trackers.append(tracker)
     return trackers

torchx/tracker/test/api_test.py

@@ -83,8 +83,6 @@ def sources(
         run_id: str,
         artifact_name: str | None = None,
     ) -> Iterable[TrackerSource]:
-        source_data = self._sources[run_id]
-
         sources = []
         for artifact_name, source_id in self._sources[run_id].items():
             if artifact_name == DEFAULT_SOURCE:
@@ -289,6 +287,28 @@ def test_build_trackers_with_module(self) -> None:
             self.assertIsInstance(tracker, MLflowTracker)
             module.assert_called_once_with(config)
 
+    def test_build_trackers_with_non_callable_module(self) -> None:
+        """load_module returns a ModuleType when no :attr is specified.
+        Modules aren't callable -- build_trackers should skip them with a warning.
+        """
+        from types import ModuleType
+
+        module = ModuleType("fake_tracker_module")
+        with (
+            patch("torchx.tracker.api.load_group", return_value=None),
+            patch(
+                "torchx.tracker.api.load_module",
+                return_value=module,
+            ),
+        ):
+            tracker_names = {"fake_tracker_module": "myconfig.txt"}
+            trackers = build_trackers(tracker_names)
+            self.assertEqual(
+                0,
+                len(list(trackers)),
+                "non-callable module should be skipped, not called as a factory",
+            )
+
     def test_build_trackers(self) -> None:
         with patch(
             "torchx.tracker.api.load_group",