pygeai 0.6.0b13__py3-none-any.whl → 0.6.1__py3-none-any.whl

pygeai/core/singleton.py

@@ -8,3 +8,27 @@ class Singleton(type):
             cls._instances[cls] = super(Singleton, cls).__call__(*args, **kwargs)
 
         return cls._instances[cls]
+
+    @classmethod
+    def reset_instance(mcs, cls):
+        """
+        Reset the singleton instance for a specific class.
+        
+        This is intended for testing purposes to ensure proper isolation
+        between tests. In production code, singletons persist for the 
+        application lifetime.
+        
+        :param cls: The class whose singleton instance should be reset
+        """
+        if cls in mcs._instances:
+            del mcs._instances[cls]
+
+    @classmethod
+    def reset_all_instances(mcs):
+        """
+        Reset all singleton instances.
+        
+        This is intended for testing purposes to ensure proper isolation
+        between tests. Use with caution as it clears all singleton caches.
+        """
+        mcs._instances.clear()

pygeai/dbg/__init__.py

@@ -1,3 +1,3 @@
-from pygeai.dbg.debugger import Debugger, Breakpoint
+from pygeai.dbg.debugger import Debugger, Breakpoint, debug_file, debug_module
 
-__all__ = ['Debugger', 'Breakpoint']
+__all__ = ['Debugger', 'Breakpoint', 'debug_file', 'debug_module']

pygeai/dbg/debugger.py

@@ -1,11 +1,12 @@
 import logging
 import sys
 import inspect
-import readline
 import pprint
+import argparse
 from types import FrameType
-from typing import Optional, Any, Callable, Set, Dict, List, Tuple
-from dataclasses import dataclass, field
+from typing import Optional, Any, Callable, Dict, List, Tuple
+from dataclasses import dataclass
+from importlib import util
 
 from pygeai.cli.geai import main as geai
 from pygeai.core.utils.console import Console
@@ -62,16 +63,19 @@ class Debugger:
     - Readline support for command history
     """
 
-    def __init__(self, target: Optional[Callable] = None, module_filter: str = "pygeai"):
+    def __init__(self, target: Optional[Callable] = None, module_filter: str = "pygeai", verbose: bool = False, log_level: str = 'DEBUG'):
         """
         Initialize the debugger.
         
-        Args:
-            target: The callable to debug. If None, defaults to pygeai.cli.geai.main
-            module_filter: Only trace modules starting with this prefix (for performance)
+        :param target: Optional[Callable] - The callable to debug. If None, defaults to pygeai.cli.geai.main (optional).
+        :param module_filter: str - Only trace modules starting with this prefix (for performance). Empty string traces all modules. Use '__main__' to trace only the main script (default is 'pygeai').
+        :param verbose: bool - If True, enable logging for pygeai modules (default is False).
+        :param log_level: str - Log level for verbose mode: 'DEBUG', 'INFO', 'WARNING', 'ERROR' (default is 'DEBUG').
         """
         self.target = target or geai
         self.module_filter = module_filter
+        self.verbose = verbose
+        self.log_level = getattr(logging, log_level.upper(), logging.DEBUG)
         self._setup_logging()
         self.logger = logging.getLogger('geai.dbg')
         
@@ -106,9 +110,31 @@ class Debugger:
             console_handler.setFormatter(formatter)
             logger.addHandler(console_handler)
             logger.propagate = False
+        
+        # If verbose mode, enable logging for pygeai modules at specified level
+        if self.verbose:
+            # Configure root logger to show at specified log level
+            root_logger = logging.getLogger()
+            if not root_logger.handlers:
+                root_logger.setLevel(self.log_level)
+                console_handler = logging.StreamHandler()
+                console_handler.setLevel(self.log_level)
+                formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
+                console_handler.setFormatter(formatter)
+                root_logger.addHandler(console_handler)
+            
+            # Ensure pygeai logger propagates to root
+            pygeai_logger = logging.getLogger('pygeai')
+            pygeai_logger.setLevel(self.log_level)
+            pygeai_logger.propagate = True
 
     def _setup_readline(self):
         """Setup readline for command history and tab completion."""
+        if not util.find_spec("readline"):
+            self.logger.debug("Readline not available (not supported on this platform)")
+            return
+
+        import readline
         try:
             import os
             histfile = os.path.expanduser("~/.geai_dbg_history")
@@ -145,13 +171,10 @@ class Debugger:
         """
         Add a breakpoint by module and/or function name.
         
-        Args:
-            module: Module name to break on (None for any)
-            function_name: Function name to break on (None for any)
-            condition: Optional condition expression (Python code)
-            
-        Returns:
-            The created Breakpoint object
+        :param module: Optional[str] - Module name to break on. None for any module (optional).
+        :param function_name: Optional[str] - Function name to break on. None for any function (optional).
+        :param condition: Optional[str] - Optional condition expression in Python code. Breakpoint only triggers if condition evaluates to True (optional).
+        :return: Breakpoint - The created Breakpoint object.
         """
         key = (module, function_name)
         if key in self.breakpoints:
@@ -206,6 +229,8 @@ class Debugger:
         """Check if we should trace this module based on filter."""
         if not module:
             return False
+        if not self.module_filter:
+            return True
         return module.startswith(self.module_filter)
 
     def _check_condition(self, bp: Breakpoint, frame: FrameType) -> bool:
@@ -214,7 +239,6 @@ class Debugger:
             return True
         
         try:
-            # Evaluate condition in frame's context
             result = eval(bp.condition, frame.f_globals, frame.f_locals)
             return bool(result)
         except Exception as e:
@@ -234,17 +258,14 @@ class Debugger:
         """Trace function calls to intercept execution."""
         module = frame.f_globals.get('__name__')
         
-        # Performance optimization: only trace filtered modules
         if not self._should_trace_module(module):
             return None
         
         function_name = frame.f_code.co_name
         
-        # Handle different event types
         if event == 'call':
             self.current_depth += 1
             
-            # Check breakpoints
             should_break = False
             for bp in self.breakpoints.values():
                 if bp.matches(module, function_name):
@@ -265,7 +286,6 @@ class Debugger:
         elif event == 'return':
             self.current_depth -= 1
             
-            # Handle step-out (return from function)
             if self.step_mode == 'return' and frame == self.step_frame:
                 self.step_mode = None
                 self.paused = True
@@ -276,7 +296,6 @@ class Debugger:
                 self.paused = False
         
         elif event == 'line':
-            # Handle step and next
             if self.step_mode == 'step':
                 self.step_mode = None
                 self.paused = True
@@ -372,7 +391,6 @@ class Debugger:
                 cmd = parts[0]
                 args = parts[1] if len(parts) > 1 else ""
                 
-                # Control flow commands
                 if cmd in ('continue', 'c'):
                     break
                 elif cmd in ('quit', 'q'):
@@ -383,7 +401,6 @@ class Debugger:
                     sys.settrace(None)
                     break
                 
-                # Stepping commands
                 elif cmd in ('step', 's'):
                     self.step_mode = 'step'
                     self.step_depth = self.current_depth
@@ -397,7 +414,6 @@ class Debugger:
                     self.step_frame = frame
                     break
                 
-                # Stack navigation
                 elif cmd in ('up', 'u'):
                     self._move_frame(1)
                 elif cmd in ('down', 'd'):
@@ -405,12 +421,10 @@ class Debugger:
                 elif cmd in ('where', 'w', 'bt', 'backtrace'):
                     self._print_stack_trace()
                 
-                # Source display
                 elif cmd in ('list', 'l'):
                     context = int(args) if args.isdigit() else 10
                     self._print_source(self.current_frame, context)
                 
-                # Variable inspection
                 elif cmd in ('print', 'p'):
                     if not args:
                         Console.write_stdout("Usage: p <expression>")
@@ -437,7 +451,6 @@ class Debugger:
                 
                 elif cmd in ('globals', 'glob'):
                     Console.write_stdout("\nGlobal variables:")
-                    # Filter out builtins
                     filtered = {k: v for k, v in self.current_frame.f_globals.items() 
                               if not k.startswith('__')}
                     pprint.pprint(filtered)
@@ -448,10 +461,8 @@ class Debugger:
                     for arg in arginfo.args:
                         Console.write_stdout(f"  {arg} = {repr(self.current_frame.f_locals.get(arg))}")
                 
-                # Breakpoint management
                 elif cmd in ('break', 'b'):
                     if not args:
-                        # List breakpoints
                         bps = self.list_breakpoints()
                         if bps:
                             Console.write_stdout("\nBreakpoints:")
@@ -460,7 +471,6 @@ class Debugger:
                         else:
                             Console.write_stdout("No breakpoints set.")
                     else:
-                        # Parse breakpoint specification: module:function or just function
                         if ':' in args:
                             mod, func = args.split(':', 1)
                             mod = mod.strip() or None
@@ -509,7 +519,6 @@ class Debugger:
                         func = args.strip()
                     self.disable_breakpoint(module=mod, function_name=func)
                 
-                # Legacy commands
                 elif cmd in ('breakpoint-module', 'bm'):
                     self.logger.info("Adding breakpoint on module")
                     module_name = input("(geai-dbg) Enter module name (or press Enter for any module): ").strip()
@@ -528,20 +537,17 @@ class Debugger:
                     self.logger.info("Listing available modules")
                     modules = [m for m in sys.modules if m.startswith(self.module_filter)]
                     Console.write_stdout(f"\nAvailable modules ({len(modules)}):")
-                    for mod in sorted(modules)[:50]:  # Limit output
+                    for mod in sorted(modules)[:50]:
                         Console.write_stdout(f"  {mod}")
                     if len(modules) > 50:
                         Console.write_stdout(f"  ... and {len(modules) - 50} more")
                 
-                # Help
                 elif cmd in ('help', 'h', '?'):
                     self._print_help()
                 
-                # Execute arbitrary Python code
                 else:
                     self.logger.info(f"Executing interactive command: {command}")
                     try:
-                        # Try exec first, if it fails try eval and print result
                         try:
                             exec(command, self.current_frame.f_globals, self.current_frame.f_locals)
                         except SyntaxError:
@@ -626,11 +632,243 @@ Examples:
             sys.settrace(None)
 
 
+def debug_file(
+    filepath: str,
+    args: Optional[List[str]] = None,
+    module_filter: Optional[str] = None,
+    breakpoint_specs: Optional[List[Tuple[Optional[str], Optional[str]]]] = None,
+    verbose: bool = False,
+    log_level: str = 'DEBUG'
+) -> Debugger:
+    """
+    Debug a Python file by executing it under the debugger.
+    
+    :param filepath: str - Path to the Python file to debug (required).
+    :param args: Optional[List[str]] - Command-line arguments to pass to the script (optional).
+    :param module_filter: Optional[str] - Module prefix to trace. None auto-detects based on file content (optional).
+    :param breakpoint_specs: Optional[List[Tuple[Optional[str], Optional[str]]]] - List of (module, function) tuples for initial breakpoints (optional).
+    :param verbose: bool - Enable verbose logging (default False).
+    :param log_level: str - Log level for verbose mode: 'DEBUG', 'INFO', 'WARNING', 'ERROR' (default 'DEBUG').
+    :return: Debugger - Configured Debugger instance ready to run.
+    :raises FileNotFoundError: If the specified file doesn't exist.
+    """
+    import os
+    
+    if not os.path.isfile(filepath):
+        raise FileNotFoundError(f"File not found: {filepath}")
+    
+    import runpy
+    
+    old_argv = sys.argv.copy()
+    sys.argv = [filepath] + (args or [])
+    
+    def target():
+        try:
+            # Use runpy to properly execute as __main__ module
+            # This ensures unittest.main() and similar tools work correctly
+            runpy.run_path(filepath, run_name='__main__')
+        finally:
+            sys.argv = old_argv
+    
+    # Auto-detect module filter based on file content
+    if module_filter is None:
+        with open(filepath, 'r') as f:
+            content = f.read()
+            if 'pygeai' in content or 'from pygeai' in content or 'import pygeai' in content:
+                module_filter = ''
+            else:
+                module_filter = '__main__'
+    
+    dbg = Debugger(target=target, module_filter=module_filter, verbose=verbose, log_level=log_level)
+    
+    if breakpoint_specs:
+        for module, function in breakpoint_specs:
+            dbg.add_breakpoint(module=module, function_name=function)
+    
+    return dbg
+
+
+def debug_module(
+    module_name: str,
+    function_name: str = 'main',
+    args: Optional[List[str]] = None,
+    module_filter: Optional[str] = None
+) -> Debugger:
+    """
+    Debug a specific module and function by importing and executing it under the debugger.
+    
+    :param module_name: str - Fully qualified module name, e.g., 'pygeai.cli.geai' (required).
+    :param function_name: str - Function to call within the module (default is 'main').
+    :param args: Optional[List[str]] - Command-line arguments to pass (optional).
+    :param module_filter: Optional[str] - Module prefix to trace. None defaults to first part of module_name (optional).
+    :return: Debugger - Configured Debugger instance with an automatic breakpoint on the target function.
+    :raises ImportError: If the module or function cannot be imported.
+    """
+    import importlib
+    
+    old_argv = sys.argv.copy()
+    sys.argv = [module_name] + (args or [])
+    
+    try:
+        module = importlib.import_module(module_name)
+        func = getattr(module, function_name)
+    except (ImportError, AttributeError) as e:
+        raise ImportError(f"Cannot import {module_name}.{function_name}: {e}")
+    
+    def target():
+        try:
+            func()
+        finally:
+            sys.argv = old_argv
+    
+    if module_filter is None:
+        module_filter = module_name.split('.')[0]
+    
+    dbg = Debugger(target=target, module_filter=module_filter)
+    dbg.add_breakpoint(module=module_name, function_name=function_name)
+    
+    return dbg
+
+
 def main():
-    """Entry point for geai-dbg command."""
-    dbg = Debugger()
-    dbg.add_breakpoint(module='pygeai.cli.geai', function_name='main')
-    dbg.run()
+    """
+    Entry point for geai-dbg command.
+    
+    Usage:
+        geai-dbg                          Debug geai CLI (default)
+        geai-dbg script.py [args...]      Debug a Python file
+        geai-dbg -m module:func [args...] Debug a module function
+        geai-dbg -h                       Show help
+    """
+    parser = argparse.ArgumentParser(
+        prog='geai-dbg',
+        description='Interactive debugger for PyGEAI applications',
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog="""
+Examples:
+  geai-dbg                              Debug the geai CLI
+  geai-dbg script.py arg1 arg2          Debug a Python file with arguments
+  geai-dbg -v script.py                 Debug with verbose logging (DEBUG level)
+  geai-dbg -v --log-level INFO script.py   Debug with INFO level logging
+  geai-dbg -m pygeai.cli.geai:main      Debug a specific module function
+  geai-dbg -b main script.py            Break on 'main' function
+  geai-dbg --filter pygeai script.py    Only trace pygeai modules
+        """
+    )
+    
+    parser.add_argument(
+        'target',
+        nargs='?',
+        default=None,
+        help='Python file to debug (omit to debug geai CLI)'
+    )
+    
+    parser.add_argument(
+        'args',
+        nargs='*',
+        help='Arguments to pass to the target'
+    )
+    
+    parser.add_argument(
+        '-m', '--module',
+        metavar='MODULE:FUNC',
+        help='Debug a module function (format: module.path:function_name)'
+    )
+    
+    parser.add_argument(
+        '-b', '--break',
+        dest='breakpoints',
+        action='append',
+        metavar='BREAKPOINT',
+        help='Set initial breakpoint (format: [module:]function, can be repeated)'
+    )
+    
+    parser.add_argument(
+        '--filter',
+        metavar='PREFIX',
+        help='Module prefix to trace (default: auto-detect)'
+    )
+    
+    parser.add_argument(
+        '--trace-all',
+        action='store_true',
+        help='Trace all modules (warning: may be slow)'
+    )
+    
+    parser.add_argument(
+        '-v', '--verbose',
+        action='store_true',
+        help='Enable verbose logging for pygeai modules'
+    )
+    
+    parser.add_argument(
+        '--log-level',
+        choices=['DEBUG', 'INFO', 'WARNING', 'ERROR'],
+        default='DEBUG',
+        help='Log level for verbose mode (default: DEBUG)'
+    )
+    
+    parsed_args = parser.parse_args()
+    
+    try:
+        if parsed_args.module:
+            if ':' in parsed_args.module:
+                module_name, func_name = parsed_args.module.split(':', 1)
+            else:
+                module_name = parsed_args.module
+                func_name = 'main'
+            
+            dbg = debug_module(
+                module_name=module_name,
+                function_name=func_name,
+                args=parsed_args.args,
+                module_filter='' if parsed_args.trace_all else parsed_args.filter
+            )
+        
+        elif parsed_args.target:
+            breakpoint_specs = []
+            if parsed_args.breakpoints:
+                for bp in parsed_args.breakpoints:
+                    if ':' in bp:
+                        mod, func = bp.split(':', 1)
+                        breakpoint_specs.append((mod or None, func or None))
+                    else:
+                        breakpoint_specs.append((None, bp))
+            
+            dbg = debug_file(
+                filepath=parsed_args.target,
+                args=parsed_args.args,
+                module_filter='' if parsed_args.trace_all else parsed_args.filter,
+                breakpoint_specs=breakpoint_specs if breakpoint_specs else None,
+                verbose=parsed_args.verbose,
+                log_level=parsed_args.log_level
+            )
+        
+        else:
+            dbg = Debugger(module_filter='pygeai')
+            dbg.add_breakpoint(module='pygeai.cli.geai', function_name='main')
+        
+        if parsed_args.breakpoints and not parsed_args.target:
+            for bp in parsed_args.breakpoints:
+                if ':' in bp:
+                    mod, func = bp.split(':', 1)
+                    dbg.add_breakpoint(module=mod or None, function_name=func or None)
+                else:
+                    dbg.add_breakpoint(function_name=bp)
+        
+        Console.write_stdout("GEAI Debugger started. Type 'h' for help, 'c' to continue, 'q' to quit.")
+        
+        dbg.run()
+    
+    except FileNotFoundError as e:
+        Console.write_stdout(f"Error: {e}")
+        sys.exit(1)
+    except ImportError as e:
+        Console.write_stdout(f"Error: {e}")
+        sys.exit(1)
+    except Exception as e:
+        logging.getLogger('geai.dbg').error(f"Debugger failed: {e}", exc_info=True)
+        sys.exit(1)
 
 
 if __name__ == "__main__":

pygeai/evaluation/clients.py

@@ -1,8 +1,6 @@
 from pygeai.core.base.clients import BaseClient
-from pygeai.core.base.session import Session
 from pygeai.core.common.exceptions import MissingRequirementException
-from pygeai.core.services.rest import ApiService
-from pygeai.core.utils.validators import validate_status_code
+from pygeai.core.services.rest import GEAIApiService
 
 
 class EvaluationClient(BaseClient):
@@ -16,4 +14,4 @@ class EvaluationClient(BaseClient):
 
         self.session.eval_url = eval_url
         token = self.session.access_token if self.session.access_token else self.session.api_key
-        self.api_service = ApiService(base_url=self.session.eval_url, token=token, project_id=self.session.project_id)
+        self.api_service = GEAIApiService(base_url=self.session.eval_url, token=token, project_id=self.session.project_id)

pygeai/evaluation/dataset/clients.py

@@ -1,4 +1,3 @@
-import json
 from pathlib import Path
 
 from pygeai.evaluation.clients import EvaluationClient

pygeai/evaluation/plan/clients.py

@@ -1,5 +1,3 @@
-import json
-
 from pygeai.evaluation.clients import EvaluationClient
 from pygeai.evaluation.plan.endpoints import LIST_EVALUATION_PLANS, CREATE_EVALUATION_PLAN, GET_EVALUATION_PLAN, \
     UPDATE_EVALUATION_PLAN, DELETE_EVALUATION_PLAN, LIST_EVALUATION_PLAN_SYSTEM_METRICS, \

pygeai/evaluation/result/clients.py

@@ -1,5 +1,3 @@
-import json
-
 from pygeai.evaluation.clients import EvaluationClient
 from pygeai.evaluation.result.endpoints import LIST_EVALUATION_RESULTS, GET_EVALUATION_RESULT
 from pygeai.core.utils.validators import validate_status_code

pygeai/gam/clients.py

@@ -1,7 +1,5 @@
-
-from pygeai import logger
 from pygeai.core.base.clients import BaseClient
-from pygeai.core.common.exceptions import MissingRequirementException, InvalidAPIResponseException
+from pygeai.core.common.exceptions import MissingRequirementException
 from pygeai.core.utils.validators import validate_status_code
 from pygeai.core.utils.parsers import parse_json_response
 from pygeai.gam.endpoints import GET_ACCESS_TOKEN_V2, GET_USER_INFO_V2, IDP_SIGNIN_V1

pygeai/health/clients.py

@@ -1,7 +1,5 @@
-
-from pygeai import logger
 from pygeai.core.base.clients import BaseClient
-from pygeai.core.common.exceptions import InvalidAPIResponseException
+
 from pygeai.core.utils.validators import validate_status_code
 from pygeai.core.utils.parsers import parse_json_response
 from pygeai.health.endpoints import STATUS_CHECK_V1

pygeai/lab/clients.py

@@ -2,7 +2,6 @@ from pygeai import logger
 from pygeai.admin.clients import AdminClient
 from pygeai.core.base.clients import BaseClient
 from pygeai.core.common.exceptions import APIError
-from pygeai.core.utils.validators import validate_status_code
 
 
 class AILabClient(BaseClient):

pygeai/lab/managers.py

@@ -1,7 +1,6 @@
 from typing import Union, Optional, List
 
 from pygeai import logger
-from pygeai.admin.clients import AdminClient
 from pygeai.core.base.mappers import ResponseMapper
 from pygeai.core.base.responses import EmptyResponse
 from pygeai.core.common.exceptions import APIError, MissingRequirementException

pygeai/lab/models.py

@@ -1,4 +1,3 @@
-import re
 from typing import Literal, Optional, List, Dict, Any, Union, Iterator
 
 from pydantic import model_validator, Field, field_validator

pygeai/lab/strategies/clients.py

@@ -1,6 +1,5 @@
-
 from pygeai import logger
-from pygeai.core.common.exceptions import InvalidAPIResponseException
+
 from pygeai.core.utils.validators import validate_status_code
 from pygeai.core.utils.parsers import parse_json_response
 from pygeai.lab.clients import AILabClient

pygeai/lab/tools/clients.py

@@ -1,7 +1,7 @@
 import json
 
 from pygeai import logger
-from pygeai.core.common.exceptions import InvalidAPIResponseException, MissingRequirementException, APIResponseError
+from pygeai.core.common.exceptions import InvalidAPIResponseException
 from pygeai.core.utils.validators import validate_status_code
 from pygeai.core.utils.parsers import parse_json_response
 from pygeai.lab.constants import VALID_SCOPES, VALID_ACCESS_SCOPES, VALID_REPORT_EVENTS
@@ -278,7 +278,7 @@ class ToolClient(AILabClient):
         :raises Exception: May be raised by `api_service.put` for network issues, authentication errors, or server-side problems (not caught here).
         """
         if not (tool_id or name):
-            raise ValueError(f"Either tool ID or tool Name must be defined in order to update tool.")
+            raise ValueError("Either tool ID or tool Name must be defined in order to update tool.")
         if scope and scope not in VALID_SCOPES:
             raise ValueError(f"Scope must be one of {', '.join(VALID_SCOPES)}.")
         if access_scope and access_scope not in VALID_ACCESS_SCOPES:

pygeai/lab/tools/mappers.py

@@ -69,7 +69,7 @@ class ToolMapper:
         if isinstance(open_api_json, str):
             try:
                 open_api_json = json.loads(open_api_json)
-            except JSONDecodeError as e:
+            except JSONDecodeError:
                 raise ValueError("open_api_json must be a valid JSON string or a dict")
 
         report_events = tool_data.get("reportEvents", "None")

pygeai/migration/strategies.py

@@ -1,4 +1,3 @@
-import sys
 from abc import ABC, abstractmethod
 from typing import Optional
 
@@ -111,7 +110,7 @@ class ProjectMigrationStrategy(MigrationStrategy):
         new_project.name = self.to_project_name
         new_project.email = self.admin_email
         
-        logger.debug(f"Creating project with destination manager:")
+        logger.debug("Creating project with destination manager:")
         logger.debug(f"  - API Key (first 20 chars): {self.to_api_key[:20] if self.to_api_key else 'None'}...")
         logger.debug(f"  - Base URL: {self.to_instance}")
         logger.debug(f"  - Project Name: {self.to_project_name}")
@@ -122,10 +121,10 @@ class ProjectMigrationStrategy(MigrationStrategy):
         except Exception as e:
             error_msg = f"Create project failed: {e}"
             logger.error(error_msg)
-            logger.error(f"  - Operation: Create project")
+            logger.error("  - Operation: Create project")
             logger.error(f"  - Base URL: {self.to_instance}")
             logger.error(f"  - API Key used (first 20 chars): {self.to_api_key[:20] if self.to_api_key else 'None'}...")
-            Console.write_stderr(f"\nDEBUG: Operation failed: Create project")
+            Console.write_stderr("\nDEBUG: Operation failed: Create project")
             Console.write_stderr(f"DEBUG: Base URL: {self.to_instance}")
             Console.write_stderr(f"DEBUG: API Key used (first 20 chars): {self.to_api_key[:20] if self.to_api_key else 'None'}...")
             raise ValueError(error_msg) from e
@@ -133,10 +132,10 @@ class ProjectMigrationStrategy(MigrationStrategy):
         if isinstance(response, ErrorListResponse):
             error_detail = response.to_dict()
             logger.error(f"Create project returned error response: {error_detail}")
-            logger.error(f"  - Operation: Create project")
+            logger.error("  - Operation: Create project")
             logger.error(f"  - Base URL: {self.to_instance}")
             logger.error(f"  - API Key used (first 20 chars): {self.to_api_key[:20] if self.to_api_key else 'None'}...")
-            Console.write_stderr(f"\nDEBUG: Operation failed: Create project")
+            Console.write_stderr("\nDEBUG: Operation failed: Create project")
             Console.write_stderr(f"DEBUG: Base URL: {self.to_instance}")
             Console.write_stderr(f"DEBUG: API Key used (first 20 chars): {self.to_api_key[:20] if self.to_api_key else 'None'}...")
             raise ValueError(f"Failed to create project: {error_detail}")