PR Review: register default templates at registry initialization

docs/template_registry.md

@@ -10,9 +10,17 @@ The `TemplateRegistry` implements the singleton pattern to ensure there's only o
 
 - **Singleton Pattern**: Ensures only one registry instance exists
 - **Thread Safety**: All operations are thread-safe using locks
-- **Case Insensitive**: Template names are normalized to lowercase
 - **Global Access**: Convenient global functions for common operations
 - **Advanced Support**: Reset functionality for environment re-usability.
+- **Default Templates**: The registry is instantiated with the default set of templates:
+  - PostStack2DTime
+  - PostStack3DTime
+  - PreStackCdpGathers3DTime
+  - PreStackShotGathers3DTime
+  - PostStack2DDepth
+  - PostStack3DDepth
+  - PreStackCdpGathers3DDepth
+  - PreStackShotGathers3DDepth
 
 ## Usage
 
@@ -94,7 +102,7 @@ Registers a template instance and returns its normalized name.
 
 - **Parameters:**
   - `instance`: Template instance implementing `AbstractDatasetTemplate`
-- **Returns:** The normalized template name (lowercase)
+- **Returns:** The template name
 - **Raises:** `ValueError` if template name is already registered
 
 #### `get(template_name: str) -> AbstractDatasetTemplate`
@@ -126,7 +134,7 @@ Checks if a template is registered.
 
 Returns a list of all registered template names.
 
-- **Returns:** List of template names (in lowercase)
+- **Returns:** List of template names
 
 #### `clear() -> None`
 
@@ -187,9 +195,8 @@ for thread in threads:
 
 1. **Use Global Functions**: For simple operations, prefer the global convenience functions
 2. **Register Early**: Register all templates during application startup
-3. **Case Insensitive Names**: Template names are automatically normalized to lowercase
-4. **Thread Safety**: The registry is thread-safe, but individual templates may not be
-5. **Testing Isolation**: Always reset the singleton in test setup/teardown
+3. **Thread Safety**: The registry is thread-safe, but individual templates may not be
+4. **Testing Isolation**: Always reset the singleton in test setup/teardown
 
 ## Example: Complete Template Management
 

src/mdio/schemas/v1/templates/template_registry.py

@@ -4,6 +4,10 @@
 from typing import Optional
 
 from mdio.schemas.v1.templates.abstract_dataset_template import AbstractDatasetTemplate
+from mdio.schemas.v1.templates.seismic_2d_poststack import Seismic2DPostStackTemplate
+from mdio.schemas.v1.templates.seismic_3d_poststack import Seismic3DPostStackTemplate
+from mdio.schemas.v1.templates.seismic_3d_prestack_cdp import Seismic3DPreStackCDPTemplate
+from mdio.schemas.v1.templates.seismic_3d_prestack_shot import Seismic3DPreStackShotTemplate
 
 
 class TemplateRegistry:
@@ -34,6 +38,7 @@ def __init__(self) -> None:
                 if not self._initialized:
                     self._templates: dict[str, AbstractDatasetTemplate] = {}
                     self._registry_lock = threading.RLock()
+                    self._register_default_templates()
                     TemplateRegistry._initialized = True
 
     def register(self, instance: AbstractDatasetTemplate) -> str:
@@ -49,13 +54,30 @@ def register(self, instance: AbstractDatasetTemplate) -> str:
             ValueError: If the template name is already registered.
         """
         with self._registry_lock:
-            name = instance.get_name().lower()
+            name = instance.get_name()
             if name in self._templates:
                 err = f"Template '{name}' is already registered."
                 raise ValueError(err)
             self._templates[name] = instance
         return name
 
+    def _register_default_templates(self) -> None:
+        """Register default templates if needed.
+
+        This method can be overridden by subclasses to register default templates.
+        """
+        self.register(Seismic2DPostStackTemplate("time"))
+        self.register(Seismic2DPostStackTemplate("depth"))
+
+        self.register(Seismic3DPostStackTemplate("time"))
+        self.register(Seismic3DPostStackTemplate("depth"))
+
+        self.register(Seismic3DPreStackCDPTemplate("time"))
+        self.register(Seismic3DPreStackCDPTemplate("depth"))
+
+        self.register(Seismic3DPreStackShotTemplate("time"))
+        self.register(Seismic3DPreStackShotTemplate("depth"))
+
     def get(self, template_name: str) -> AbstractDatasetTemplate:
         """Get a template from the registry by its name.
 
@@ -69,7 +91,7 @@ def get(self, template_name: str) -> AbstractDatasetTemplate:
             KeyError: If the template is not registered.
         """
         with self._registry_lock:
-            name = template_name.lower()
+            name = template_name
             if name not in self._templates:
                 err = f"Template '{name}' is not registered."
                 raise KeyError(err)
@@ -85,7 +107,7 @@ def unregister(self, template_name: str) -> None:
             KeyError: If the template is not registered.
         """
         with self._registry_lock:
-            name = template_name.lower()
+            name = template_name
             if name not in self._templates:
                 err_msg = f"Template '{name}' is not registered."
                 raise KeyError(err_msg)
@@ -101,7 +123,7 @@ def is_registered(self, template_name: str) -> bool:
             True if the template is registered, False otherwise.
         """
         with self._registry_lock:
-            name = template_name.lower()
+            name = template_name
             return name in self._templates
 
     def list_all_templates(self) -> list[str]:

tests/unit/v1/templates/test_template_registry.py

@@ -146,34 +146,22 @@ def test_unregister_nonexistent_template(self) -> None:
         with pytest.raises(KeyError, match="Template 'nonexistent' is not registered"):
             registry.unregister("nonexistent")
 
-    def test_case_insensitive_operations(self) -> None:
-        """Test that all operations are case-insensitive."""
-        registry = TemplateRegistry()
-        template = MockDatasetTemplate("Test_Template")
-
-        # Register template
-        registry.register(template)
-
-        # All these should work (case insensitive)
-        assert registry.is_registered("test_template")
-        assert registry.is_registered("TEST_TEMPLATE")
-        assert registry.is_registered("Test_Template")
-
-        # Get with different cases
-        assert registry.get("test_template") is template
-        assert registry.get("TEST_TEMPLATE") is template
-        assert registry.get("Test_Template") is template
-
-        # Unregister with different case
-        registry.unregister("TEST_TEMPLATE")
-        assert not registry.is_registered("test_template")
-
     def test_list_all_templates(self) -> None:
         """Test listing all registered templates."""
         registry = TemplateRegistry()
 
-        # Initially empty
-        assert registry.list_all_templates() == []
+        # Default templates are always installed
+        templates = list_templates()
+        assert len(templates) == 8
+        assert "PostStack2DTime" in templates
+        assert "PostStack3DTime" in templates
+        assert "PreStackCdpGathers3DTime" in templates
+        assert "PreStackShotGathers3DTime" in templates
+
+        assert "PostStack2DDepth" in templates
+        assert "PostStack3DDepth" in templates
+        assert "PreStackCdpGathers3DDepth" in templates
+        assert "PreStackShotGathers3DDepth" in templates
 
         # Add some templates
         template1 = MockDatasetTemplate("Template_One")
@@ -183,29 +171,42 @@ def test_list_all_templates(self) -> None:
         registry.register(template2)
 
         templates = registry.list_all_templates()
-        assert len(templates) == 2
-        assert "template_one" in templates
-        assert "template_two" in templates
+        assert len(templates) == 10
+        assert "Template_One" in templates
+        assert "Template_Two" in templates
 
     def test_clear_templates(self) -> None:
         """Test clearing all templates."""
         registry = TemplateRegistry()
 
+        # Default templates are always installed
+        templates = list_templates()
+        assert len(templates) == 8
+
         # Add some templates
-        template1 = MockDatasetTemplate("template1")
-        template2 = MockDatasetTemplate("template2")
+        template1 = MockDatasetTemplate("Template1")
+        template2 = MockDatasetTemplate("Template2")
 
         registry.register(template1)
         registry.register(template2)
 
-        assert len(registry.list_all_templates()) == 2
+        assert len(registry.list_all_templates()) == 10
 
         # Clear all
         registry.clear()
 
         assert len(registry.list_all_templates()) == 0
-        assert not registry.is_registered("template1")
-        assert not registry.is_registered("template2")
+        assert not registry.is_registered("Template1")
+        assert not registry.is_registered("Template2")
+        # default templates are also cleared
+        assert not registry.is_registered("PostStack2DTime")
+        assert not registry.is_registered("PostStack3DTime")
+        assert not registry.is_registered("PreStackCdpGathers3DTime")
+        assert not registry.is_registered("PreStackShotGathers3DTime")
+        assert not registry.is_registered("PostStack2DDepth")
+        assert not registry.is_registered("PostStack3DDepth")
+        assert not registry.is_registered("PreStackCdpGathers3DDepth")
+        assert not registry.is_registered("PreStackShotGathers3DDepth")
 
     def test_reset_instance(self) -> None:
         """Test resetting the singleton instance."""
@@ -216,12 +217,22 @@ def test_reset_instance(self) -> None:
         # Reset the instance
         TemplateRegistry._reset_instance()
 
-        # New instance should be different and empty
+        # New instance should be different and contain default templates only
         registry2 = TemplateRegistry()
 
         assert registry1 is not registry2
         assert not registry2.is_registered("test")
-        assert len(registry2.list_all_templates()) == 0
+
+        # default templates are registered
+        assert len(registry2.list_all_templates()) == 8
+        assert registry2.is_registered("PostStack2DTime")
+        assert registry2.is_registered("PostStack3DTime")
+        assert registry2.is_registered("PreStackCdpGathers3DTime")
+        assert registry2.is_registered("PreStackShotGathers3DTime")
+        assert registry2.is_registered("PostStack2DDepth")
+        assert registry2.is_registered("PostStack3DDepth")
+        assert registry2.is_registered("PreStackCdpGathers3DDepth")
+        assert registry2.is_registered("PreStackShotGathers3DDepth")
 
 
 class TestGlobalFunctions:
@@ -258,14 +269,27 @@ def test_register_template_global(self) -> None:
 
     def test_list_templates_global(self) -> None:
         """Test global template listing."""
+        # Default templates are always installed
+        templates = list_templates()
+        assert len(templates) == 8
+        assert "PostStack2DTime" in templates
+        assert "PostStack3DTime" in templates
+        assert "PreStackCdpGathers3DTime" in templates
+        assert "PreStackShotGathers3DTime" in templates
+
+        assert "PostStack2DDepth" in templates
+        assert "PostStack3DDepth" in templates
+        assert "PreStackCdpGathers3DDepth" in templates
+        assert "PreStackShotGathers3DDepth" in templates
+
         template1 = MockDatasetTemplate("template1")
         template2 = MockDatasetTemplate("template2")
 
         register_template(template1)
         register_template(template2)
 
         templates = list_templates()
-        assert len(templates) == 2
+        assert len(templates) == 10
         assert "template1" in templates
         assert "template2" in templates
 
@@ -310,7 +334,8 @@ def register_template_worker(template_id: int) -> None:
         # All registrations should succeed
         assert len(errors) == 0
         assert len(results) == 10
-        assert len(registry.list_all_templates()) == 10
+        # Including 8 default templates
+        assert len(registry.list_all_templates()) == 18
 
         # Check all templates are registered
         for i in range(10):