refactor catalog loading again

Author: edwardchalstrey1

src/pygambit/catalog/__init__.py

@@ -6,4 +6,13 @@
 def __getattr__(name: str):
     """Lazy load catalog games on access."""
     from . import catalog as _catalog_module
-    return getattr(_catalog_module, name)
+
+    # Don't try to load if already initializing to prevent recursion
+    if not _catalog_module._catalog_initializing:
+        # Ensure all catalog games are loaded
+        _catalog_module._ensure_catalog_loaded()
+
+    if hasattr(_catalog_module, name):
+        return getattr(_catalog_module, name)
+
+    raise AttributeError(f"module '{__name__}' has no attribute '{name}'")

src/pygambit/catalog/catalog.py

@@ -47,10 +47,6 @@ def __init_subclass__(cls, **kwargs):
         if cls.__name__ == "CatalogGameFromContrib" or issubclass(cls, CatalogGameFromContrib):
             return
 
-        # Load game and extract metadata immediately when class is defined
-        cls.game = cls._game()
-        cls._extract_description(cls.game)
-
 
 class CatalogGameFromContrib(CatalogGame):
     """
@@ -84,13 +80,9 @@ def _load_game(cls) -> Game:
             raise ValueError(f"Game file extension must be 'nfg' or 'efg', got '{game_type}'")
 
     def __init_subclass__(cls, **kwargs):
-        """Validate and extract metadata when subclass is defined."""
+        """Validate metadata when subclass is defined."""
         super().__init_subclass__(**kwargs)
 
-        # Load game and extract metadata immediately when class is defined
-        cls.game = cls._load_game()
-        cls._extract_description(cls.game)
-
 
 def games(
     num_actions: int | None = None,
@@ -144,8 +136,8 @@ def games(
     >>> games(x=1)  # Games with a custom metadata field 'x' equal to 1
     >>> games(is_tree=True, num_players=2)  # 2-player extensive-form games
     """
-    # Import manually coded games to ensure they are registered in the catalog
-    _load_coded_games()
+    # Ensure all games are loaded
+    _ensure_catalog_loaded()
 
     # Filter by extensive-form if filtering by tree-specific attributes
     if (
@@ -165,6 +157,19 @@ def get_all_subclasses(cls):
                 all_subclasses.extend(get_all_subclasses(subclass))
                 continue
 
+            # Ensure game is instantiated before filtering
+            if subclass.game is None:
+                try:
+                    if issubclass(subclass, CatalogGameFromContrib):
+                        subclass.game = subclass._load_game()
+                    else:
+                        subclass.game = subclass._game()
+                    subclass._extract_description(subclass.game)
+                except Exception:
+                    # Skip games that fail to load
+                    all_subclasses.extend(get_all_subclasses(subclass))
+                    continue
+
             if is_tree is not None and is_tree != subclass.game.is_tree:
                 all_subclasses.extend(get_all_subclasses(subclass))
                 continue
@@ -250,6 +255,27 @@ def get_all_subclasses(cls):
 
 _CATALOG_YAML = Path(__file__).parent / "catalog.yml"
 
+_catalog_initialized = False
+_catalog_initializing = False
+
+
+def _ensure_catalog_loaded():
+    """Ensure both YAML and coded games are loaded."""
+    global _catalog_initialized, _catalog_initializing
+    if _catalog_initialized:
+        return
+    if _catalog_initializing:
+        return  # Already loading, prevent re-entrance
+
+    _catalog_initializing = True
+    try:
+        _catalog_data = _load_catalog_from_yaml(_CATALOG_YAML)
+        _generate_contrib_game_classes(_catalog_data)
+        _load_coded_games()
+        _catalog_initialized = True
+    finally:
+        _catalog_initializing = False
+
 
 def _load_catalog_from_yaml(path: Path) -> dict[str, dict]:
     if not path.exists():
@@ -315,8 +341,3 @@ def _load_coded_games():
                 globals()[name] = obj
 
     _coded_games_loaded = True
-
-
-# Generate classes at import time
-_catalog_data = _load_catalog_from_yaml(_CATALOG_YAML)
-_generate_contrib_game_classes(_catalog_data)