- adding usage to specialist execution

- Correcting implementation of usage
- Removed some obsolete debug statements

common/utils/cache/config_cache.py

@@ -69,10 +69,8 @@ class BaseConfigCacheHandler(CacheHandler[Dict[str, Any]]):
         Returns:
             Configuration data
         """
-        current_app.logger.debug(f"Loading specific configuration for {type_name}, version: {version_str} - no cache")
         version_tree = self.version_tree_cache.get_versions(type_name)
         versions = version_tree['versions']
-        current_app.logger.debug(f"Loaded specific versions for {type_name}, versions: {versions}")
 
         if version_str == 'latest':
             version_str = version_tree['latest_version']
@@ -81,12 +79,10 @@ class BaseConfigCacheHandler(CacheHandler[Dict[str, Any]]):
             raise ValueError(f"Version {version_str} not found for {type_name}")
 
         file_path = versions[version_str]['file_path']
-        current_app.logger.debug(f'Trying to load configuration from {file_path}')
 
         try:
             with open(file_path) as f:
                 config = yaml.safe_load(f)
-                current_app.logger.debug(f"Loaded config for {type_name}{version_str}: {config}")
                 return config
         except Exception as e:
             raise ValueError(f"Error loading config from {file_path}: {e}")
@@ -103,8 +99,6 @@ class BaseConfigCacheHandler(CacheHandler[Dict[str, Any]]):
         Returns:
             Configuration data
         """
-        current_app.logger.debug(f"Trying to retrieve config for {self.config_type}, type name: {type_name}, "
-                                 f"version: {version}")
         if version is None:
             version_str = self.version_tree_cache.get_latest_version(type_name)
         elif is_major_minor(version):
@@ -145,7 +139,6 @@ class BaseConfigVersionTreeCacheHandler(CacheHandler[Dict[str, Any]]):
         Returns:
             Dict containing available versions and their metadata
         """
-        current_app.logger.debug(f"Loading version tree for {type_name} - no cache")
         type_path = Path(self._config_dir) / type_name
         if not type_path.exists():
             raise ValueError(f"No configuration found for type {type_name}")
@@ -180,8 +173,6 @@ class BaseConfigVersionTreeCacheHandler(CacheHandler[Dict[str, Any]]):
                 current_app.logger.error(f"Error loading version {ver}: {e}")
                 continue
 
-        current_app.logger.debug(f"Loaded versions for {type_name}: {versions}")
-        current_app.logger.debug(f"Latest version for {type_name}: {latest_version}")
         return {
             'versions': versions,
             'latest_version': latest_version
@@ -221,7 +212,6 @@ class BaseConfigVersionTreeCacheHandler(CacheHandler[Dict[str, Any]]):
         Returns:
             Dict with version information
         """
-        current_app.logger.debug(f"Trying to get version tree for {self.config_type}, {type_name}")
         return self.get(
             lambda type_name: self._load_version_tree(type_name),
             type_name=type_name
@@ -319,7 +309,6 @@ class BaseConfigTypesCacheHandler(CacheHandler[Dict[str, Any]]):
 
     def _load_type_definitions(self) -> Dict[str, Dict[str, str]]:
         """Load type definitions from the corresponding type_defs module"""
-        current_app.logger.debug(f"Loading type definitions for {self.config_type} - no cache")
         if not self._types_module:
             raise ValueError("_types_module must be set by subclass")
 
@@ -331,13 +320,10 @@ class BaseConfigTypesCacheHandler(CacheHandler[Dict[str, Any]]):
             for type_id, info in self._types_module.items()
         }
 
-        current_app.logger.debug(f"Loaded type definitions: {type_definitions}")
-
         return type_definitions
 
     def get_types(self) -> Dict[str, Dict[str, str]]:
         """Get dictionary of available types with name and description"""
-        current_app.logger.debug(f"Trying to retrieve type definitions for {self.config_type}")
         result = self.get(
             lambda type_name: self._load_type_definitions(),
             type_name=f'{self.config_type}_types',