claude-mpm 3.9.9__py3-none-any.whl → 4.0.3__py3-none-any.whl

claude_mpm/utils/import_migration_example.py

@@ -4,77 +4,29 @@ This file demonstrates how to replace the common try/except ImportError
 pattern with the new safe_import utility.
 """
 
-# BEFORE: The old pattern used throughout the codebase
-# -----------------------------------------------------
-# try:
-#     from ..core.logger import get_logger
-# except ImportError:
-#     from utils.logger import get_logger
-#
-# try:
-#     from ..core.agent_registry import AgentRegistryAdapter
-# except ImportError:
-#     from core.agent_registry import AgentRegistryAdapter
-
-
 # AFTER: Using safe_import utility
 # --------------------------------
 from claude_mpm.utils.imports import safe_import, safe_import_multiple
 
 # Method 1: Individual imports
-get_logger = safe_import('..utils.logger', 'utils.logger', from_list=['get_logger'])
-AgentRegistryAdapter = safe_import('..core.agent_registry', 'core.agent_registry', 
-                                  from_list=['AgentRegistryAdapter'])
+get_logger = safe_import("..utils.logger", "utils.logger", from_list=["get_logger"])
+AgentRegistryAdapter = safe_import(
+    "..core.agent_registry", "core.agent_registry", from_list=["AgentRegistryAdapter"]
+)
 
 # Method 2: Batch imports (recommended for multiple imports)
-imports = safe_import_multiple([
-    ('..utils.logger', 'utils.logger', ['get_logger']),
-    ('..core.agent_registry', 'core.agent_registry', ['AgentRegistryAdapter']),
-])
-
-get_logger = imports.get('get_logger')
-AgentRegistryAdapter = imports.get('AgentRegistryAdapter')
+imports = safe_import_multiple(
+    [
+        ("..utils.logger", "utils.logger", ["get_logger"]),
+        ("..core.agent_registry", "core.agent_registry", ["AgentRegistryAdapter"]),
+    ]
+)
 
+get_logger = imports.get("get_logger")
+AgentRegistryAdapter = imports.get("AgentRegistryAdapter")
 
 # MIGRATION GUIDE
 # ---------------
-# 1. Add import: from claude_mpm.utils.imports import safe_import
-# 
-# 2. Replace try/except blocks:
-#    FROM:
-#      try:
-#          from ..module import something
-#      except ImportError:
-#          from module import something
-#    
-#    TO:
-#      something = safe_import('..module', 'module', from_list=['something'])
-#
-# 3. For multiple imports from same module:
-#    FROM:
-#      try:
-#          from ..module import foo, bar, baz
-#      except ImportError:
-#          from module import foo, bar, baz
-#    
-#    TO:
-#      foo, bar, baz = safe_import('..module', 'module', from_list=['foo', 'bar', 'baz'])
-#
-# 4. For whole module imports:
-#    FROM:
-#      try:
-#          from .. import module
-#      except ImportError:
-#          import module
-#    
-#    TO:
-#      module = safe_import('..module', 'module')
-
 
 # BENEFITS
 # --------
-# 1. Reduces code duplication (97 files can be simplified)
-# 2. Centralizes import error handling logic
-# 3. Provides optional logging for debugging import issues
-# 4. Maintains the same functionality with cleaner code
-# 5. Makes the codebase more maintainable

claude_mpm/utils/imports.py

@@ -7,50 +7,50 @@ used throughout the claude_mpm codebase.
 
 import importlib
 import logging
-from typing import Optional, Any, List, Union
+from typing import Any, List, Optional, Union
 
 
 def safe_import(
     module_name: str,
     fallback_name: Optional[str] = None,
     from_list: Optional[List[str]] = None,
-    logger: Optional[logging.Logger] = None
+    logger: Optional[logging.Logger] = None,
 ) -> Optional[Any]:
     """
     Safely import a module with fallback support.
-    
+
     Attempts to import a module using the primary module name first,
     then falls back to the fallback name if provided. This is useful
     for handling both relative and absolute imports.
-    
+
     Args:
         module_name: Primary module name to import (e.g., '..utils.logger')
         fallback_name: Fallback module name if primary fails (e.g., 'utils.logger')
         from_list: List of names to import from the module (for 'from X import Y' style)
         logger: Optional logger for debugging import attempts
-        
+
     Returns:
         The imported module or specific attribute(s) if from_list is provided.
         Returns None if all import attempts fail.
-        
+
     Examples:
         # Import entire module
         logger_module = safe_import('..utils.logger', 'utils.logger')
-        
+
         # Import specific function (returns the function directly)
         get_logger = safe_import('..utils.logger', 'utils.logger', ['get_logger'])
-        
+
         # Import multiple items (returns tuple)
-        logger, setup = safe_import('..utils.logger', 'utils.logger', 
+        logger, setup = safe_import('..utils.logger', 'utils.logger',
                                    ['get_logger', 'setup_logging'])
     """
     # Try primary import
     try:
         if logger:
             logger.debug(f"Attempting import: {module_name}")
-        
+
         module = importlib.import_module(module_name)
-        
+
         if from_list:
             # Handle 'from X import Y' style imports
             results = []
@@ -61,26 +61,26 @@ def safe_import(
                     if logger:
                         logger.warning(f"Module {module_name} has no attribute {name}")
                     results.append(None)
-            
+
             # Return single item if only one requested, otherwise tuple
             if len(results) == 1:
                 return results[0]
             return tuple(results)
-        
+
         return module
-        
+
     except ImportError as e:
         if logger:
             logger.debug(f"Primary import failed: {e}")
-        
+
         # Try fallback if provided
         if fallback_name:
             try:
                 if logger:
                     logger.debug(f"Attempting fallback import: {fallback_name}")
-                
+
                 module = importlib.import_module(fallback_name)
-                
+
                 if from_list:
                     # Handle 'from X import Y' style imports
                     results = []
@@ -89,61 +89,64 @@ def safe_import(
                             results.append(getattr(module, name))
                         else:
                             if logger:
-                                logger.warning(f"Module {fallback_name} has no attribute {name}")
+                                logger.warning(
+                                    f"Module {fallback_name} has no attribute {name}"
+                                )
                             results.append(None)
-                    
+
                     # Return single item if only one requested, otherwise tuple
                     if len(results) == 1:
                         return results[0]
                     return tuple(results)
-                
+
                 return module
-                
+
             except ImportError as e2:
                 if logger:
                     logger.debug(f"Fallback import also failed: {e2}")
-    
+
     # All imports failed
     if logger:
-        logger.error(f"Failed to import {module_name}" + 
-                    (f" or {fallback_name}" if fallback_name else ""))
-    
+        logger.error(
+            f"Failed to import {module_name}"
+            + (f" or {fallback_name}" if fallback_name else "")
+        )
+
     return None
 
 
 def safe_import_multiple(
-    imports: List[Union[tuple, dict]],
-    logger: Optional[logging.Logger] = None
+    imports: List[Union[tuple, dict]], logger: Optional[logging.Logger] = None
 ) -> dict:
     """
     Import multiple modules with fallback support.
-    
+
     Args:
         imports: List of import specifications. Each can be:
             - tuple: (primary_name, fallback_name, from_list)
             - dict: {'primary': '...', 'fallback': '...', 'from_list': [...], 'as': 'alias'}
         logger: Optional logger for debugging
-        
+
     Returns:
         Dictionary mapping module/attribute names to imported objects
-        
+
     Example:
         imports = [
             ('..utils.logger', 'utils.logger', ['get_logger']),
-            {'primary': '..core.agent_registry', 'fallback': 'core.agent_registry', 
+            {'primary': '..core.agent_registry', 'fallback': 'core.agent_registry',
              'from_list': ['AgentRegistry'], 'as': 'registry'}
         ]
-        
+
         imported = safe_import_multiple(imports)
         # Result: {'get_logger': <function>, 'registry': <class>}
     """
     results = {}
-    
+
     for spec in imports:
         if isinstance(spec, tuple):
             primary, fallback, from_list = spec
             imported = safe_import(primary, fallback, from_list, logger)
-            
+
             if imported is not None:
                 if from_list and len(from_list) == 1:
                     # Single import gets stored by its name
@@ -155,17 +158,17 @@ def safe_import_multiple(
                             results[name] = imported[i]
                 else:
                     # Module import gets stored by last part of module name
-                    module_alias = primary.split('.')[-1]
+                    module_alias = primary.split(".")[-1]
                     results[module_alias] = imported
-                    
+
         elif isinstance(spec, dict):
-            primary = spec.get('primary')
-            fallback = spec.get('fallback')
-            from_list = spec.get('from_list')
-            alias = spec.get('as')
-            
+            primary = spec.get("primary")
+            fallback = spec.get("fallback")
+            from_list = spec.get("from_list")
+            alias = spec.get("as")
+
             imported = safe_import(primary, fallback, from_list, logger)
-            
+
             if imported is not None:
                 if alias:
                     results[alias] = imported
@@ -176,7 +179,7 @@ def safe_import_multiple(
                         if imported[i] is not None:
                             results[name] = imported[i]
                 else:
-                    module_alias = primary.split('.')[-1]
+                    module_alias = primary.split(".")[-1]
                     results[module_alias] = imported
-    
-    return results
+
+    return results