michael-agent 1.0.0__py3-none-any.whl → 1.0.2__py3-none-any.whl

michael_agent/utils/jd_utils.py

@@ -0,0 +1,34 @@
+import os
+import json
+import logging
+from typing import Dict, Any, Optional
+
+from config import settings
+
+logger = logging.getLogger(__name__)
+
+def load_job_description(job_id: str = None, job_file_path: str = None) -> Dict[str, Any]:
+    """Load job description from file"""
+    try:
+        # If path is provided directly, use it
+        if job_file_path and os.path.exists(job_file_path):
+            with open(job_file_path, 'r') as f:
+                job_data = json.load(f)
+                return job_data
+        
+        # If job_id is provided, look for the file in job_descriptions directory
+        if job_id:
+            # Look only in the root job_descriptions directory
+            main_path = os.path.join("job_descriptions", f"{job_id}.json")
+            if os.path.exists(main_path):
+                with open(main_path, 'r') as f:
+                    job_data = json.load(f)
+                    return job_data
+            
+            logger.error(f"Job description file not found for job_id {job_id} at {main_path}")
+        
+        logger.error("No valid job ID or file path provided")
+        return None
+    except Exception as e:
+        logger.error(f"Error loading job description: {e}")
+        return None

michael_agent/utils/lms_api.py

@@ -0,0 +1,226 @@
+"""
+LMS (Learning Management System) API integration utilities
+Supports integration with HackerRank, TestGorilla, or custom LMS APIs
+"""
+
+import os
+import requests
+import json
+import logging
+from typing import Dict, List, Optional, Any
+
+from config import settings
+
+logger = logging.getLogger(__name__)
+
+class LMSIntegration:
+    """Base class for LMS integrations"""
+    
+    def __init__(self):
+        self.api_url = settings.LMS_API_URL
+        self.api_key = settings.LMS_API_KEY
+    
+    def send_assessment(self, candidate_email, candidate_name, position_name):
+        """Send an assessment to a candidate (to be implemented by subclasses)"""
+        raise NotImplementedError("Subclasses must implement this method")
+    
+    def get_assessment_results(self, assessment_id):
+        """Get the results of an assessment (to be implemented by subclasses)"""
+        raise NotImplementedError("Subclasses must implement this method")
+
+class HackerRankIntegration(LMSIntegration):
+    """Integration with HackerRank API"""
+    
+    def __init__(self):
+        super().__init__()
+        self.headers = {
+            "Content-Type": "application/json",
+            "Authorization": f"Bearer {self.api_key}"
+        }
+    
+    def send_assessment(self, candidate_email, candidate_name, position_name):
+        """Send a HackerRank test to a candidate"""
+        try:
+            # Find test ID based on position name (example - would need to be customized)
+            test_id = self._get_test_id_for_position(position_name)
+            
+            # Prepare API payload
+            payload = {
+                "test_id": test_id,
+                "candidates": [
+                    {
+                        "email": candidate_email,
+                        "first_name": candidate_name.split()[0],
+                        "last_name": candidate_name.split()[-1] if len(candidate_name.split()) > 1 else ""
+                    }
+                ],
+                "subject": f"Assessment for {position_name} position",
+                "message": f"Dear {candidate_name.split()[0]},\n\nPlease complete the following assessment for the {position_name} position."
+            }
+            
+            # Make API request to send test invitation
+            response = requests.post(
+                f"{self.api_url}/tests/{test_id}/candidates/invite",
+                headers=self.headers,
+                json=payload
+            )
+            
+            response.raise_for_status()
+            result = response.json()
+            
+            logger.info(f"Assessment sent to {candidate_email} via HackerRank")
+            return {
+                "success": True,
+                "assessment_id": result.get("assessment_id"),
+                "invitation_id": result.get("invitation_id"),
+                "status": "sent"
+            }
+        except requests.exceptions.RequestException as e:
+            logger.error(f"Error sending HackerRank assessment: {str(e)}")
+            return {
+                "success": False,
+                "error": str(e)
+            }
+    
+    def get_assessment_results(self, assessment_id):
+        """Get the results of a HackerRank assessment"""
+        try:
+            response = requests.get(
+                f"{self.api_url}/assessments/{assessment_id}",
+                headers=self.headers
+            )
+            
+            response.raise_for_status()
+            result = response.json()
+            
+            return {
+                "success": True,
+                "status": result.get("status"),
+                "score": result.get("score"),
+                "completed_at": result.get("completed_at"),
+                "results": result.get("results")
+            }
+        except requests.exceptions.RequestException as e:
+            logger.error(f"Error getting HackerRank assessment results: {str(e)}")
+            return {
+                "success": False,
+                "error": str(e)
+            }
+    
+    def _get_test_id_for_position(self, position_name):
+        """
+        Map position name to test ID
+        This is a simplified example - in practice, you would have a mapping or search functionality
+        """
+        # Example mapping - would need to be customized
+        position_to_test_map = {
+            "Software Engineer": "12345",
+            "Data Scientist": "23456",
+            "DevOps Engineer": "34567",
+            # Add more mappings as needed
+        }
+        
+        # Default to a general assessment if position not found
+        return position_to_test_map.get(position_name, "default_test_id")
+
+class TestGorillaIntegration(LMSIntegration):
+    """Integration with TestGorilla API"""
+    
+    def __init__(self):
+        super().__init__()
+        self.headers = {
+            "Content-Type": "application/json",
+            "Authorization": f"Token {self.api_key}"
+        }
+    
+    def send_assessment(self, candidate_email, candidate_name, position_name):
+        """Send a TestGorilla assessment to a candidate"""
+        try:
+            # Find assessment ID based on position name
+            assessment_id = self._get_assessment_id_for_position(position_name)
+            
+            # Prepare API payload
+            payload = {
+                "email": candidate_email,
+                "first_name": candidate_name.split()[0],
+                "last_name": candidate_name.split()[-1] if len(candidate_name.split()) > 1 else "",
+                "language": "en",
+                "assessment": assessment_id
+            }
+            
+            # Make API request to send invitation
+            response = requests.post(
+                f"{self.api_url}/candidates/",
+                headers=self.headers,
+                json=payload
+            )
+            
+            response.raise_for_status()
+            result = response.json()
+            
+            logger.info(f"Assessment sent to {candidate_email} via TestGorilla")
+            return {
+                "success": True,
+                "candidate_id": result.get("id"),
+                "invitation_url": result.get("invitation_url"),
+                "status": "invited"
+            }
+        except requests.exceptions.RequestException as e:
+            logger.error(f"Error sending TestGorilla assessment: {str(e)}")
+            return {
+                "success": False,
+                "error": str(e)
+            }
+    
+    def get_assessment_results(self, candidate_id):
+        """Get the results of a TestGorilla assessment"""
+        try:
+            response = requests.get(
+                f"{self.api_url}/candidates/{candidate_id}/",
+                headers=self.headers
+            )
+            
+            response.raise_for_status()
+            result = response.json()
+            
+            return {
+                "success": True,
+                "status": result.get("status"),
+                "score": result.get("score"),
+                "completed_at": result.get("completed_at"),
+                "test_results": result.get("test_results", [])
+            }
+        except requests.exceptions.RequestException as e:
+            logger.error(f"Error getting TestGorilla assessment results: {str(e)}")
+            return {
+                "success": False,
+                "error": str(e)
+            }
+    
+    def _get_assessment_id_for_position(self, position_name):
+        """
+        Map position name to assessment ID
+        This is a simplified example - in practice, you would have a mapping or search functionality
+        """
+        # Example mapping - would need to be customized
+        position_to_assessment_map = {
+            "Software Engineer": "abc123",
+            "Data Scientist": "def456",
+            "DevOps Engineer": "ghi789",
+            # Add more mappings as needed
+        }
+        
+        # Default to a general assessment if position not found
+        return position_to_assessment_map.get(position_name, "default_assessment_id")
+
+def get_lms_client() -> LMSIntegration:
+    """Factory function to get the appropriate LMS client based on configuration"""
+    lms_type = settings.LMS_TYPE.lower()
+    
+    if lms_type == "hackerrank":
+        return HackerRankIntegration()
+    elif lms_type == "testgorilla":
+        return TestGorillaIntegration()
+    else:
+        logger.warning(f"Unsupported LMS type: {lms_type}, falling back to HackerRank")
+        return HackerRankIntegration()

michael_agent/utils/logging_utils.py

@@ -0,0 +1,192 @@
+"""
+Logging utilities for SmartRecruitAgent
+Provides consistent logging configuration and helpers
+"""
+
+import os
+import sys
+import json
+import logging
+import traceback
+from datetime import datetime
+from functools import wraps
+from typing import Dict, Any, Callable, Optional
+
+# Import config
+from config import settings
+
+# Configure the base logging system
+def setup_logger(name: str, log_file: Optional[str] = None, level: int = logging.INFO) -> logging.Logger:
+    """Set up and configure a logger instance"""
+    logger = logging.getLogger(name)
+    logger.setLevel(level)
+    
+    # Create formatter
+    formatter = logging.Formatter(
+        '%(asctime)s | %(levelname)s | %(name)s | %(message)s',
+        datefmt='%Y-%m-%d %H:%M:%S'
+    )
+    
+    # Add console handler
+    console_handler = logging.StreamHandler(sys.stdout)
+    console_handler.setFormatter(formatter)
+    logger.addHandler(console_handler)
+    
+    # Add file handler if log file is specified
+    if log_file:
+        os.makedirs(os.path.dirname(log_file), exist_ok=True)
+        file_handler = logging.FileHandler(log_file)
+        file_handler.setFormatter(formatter)
+        logger.addHandler(file_handler)
+    
+    return logger
+
+# Create the workflow logger
+workflow_logger = setup_logger(
+    'workflow',
+    os.path.join(settings.LOG_DIR, 'workflow.log')
+)
+
+# Create the state transitions logger
+state_logger = setup_logger(
+    'state_transitions',
+    os.path.join(settings.LOG_DIR, 'state_transitions.log')
+)
+
+def log_state_transition(before_state: Dict[str, Any], after_state: Dict[str, Any], step_name: str) -> None:
+    """Log state transitions between workflow steps"""
+    # Create a simplified log of what changed
+    changes = {}
+    
+    # Track only the keys that changed
+    for key in after_state:
+        if key not in before_state or before_state[key] != after_state[key]:
+            # For complex objects, just note they changed rather than logging entire content
+            if isinstance(after_state[key], dict) or isinstance(after_state[key], list):
+                changes[key] = f"{type(after_state[key]).__name__} modified"
+            else:
+                changes[key] = after_state[key]
+    
+    # Record any errors added in this step
+    errors = []
+    if "errors" in after_state and isinstance(after_state["errors"], list):
+        before_errors_count = len(before_state.get("errors", []))
+        if len(after_state["errors"]) > before_errors_count:
+            errors = after_state["errors"][before_errors_count:]
+    
+    # Create the log entry
+    log_entry = {
+        "timestamp": datetime.now().isoformat(),
+        "step": step_name,
+        "job_id": after_state.get("job_id", "unknown"),
+        "candidate": after_state.get("candidate_name", "unknown"),
+        "status": after_state.get("status", "unknown"),
+        "changes": changes,
+        "errors": errors
+    }
+    
+    # Add a JSON serialization helper function
+    def json_serializable(obj):
+        if isinstance(obj, (str, int, float, bool, type(None))):
+            return obj
+        elif isinstance(obj, (list, tuple)):
+            return [json_serializable(item) for item in obj]
+        elif isinstance(obj, dict):
+            return {k: json_serializable(v) for k, v in obj.items() if isinstance(k, str)}
+        return str(obj)  # Convert non-serializable objects to strings
+    
+    # Modify the log_entry or use the helper
+    serializable_log_entry = json_serializable(log_entry)
+    # Log to file
+    state_logger.info(json.dumps(serializable_log_entry))
+
+def log_step(func: Callable) -> Callable:
+    """Decorator for logging workflow step execution with detailed tracking"""
+    @wraps(func)
+    def wrapper(state: Dict[str, Any], *args, **kwargs) -> Dict[str, Any]:
+        step_name = func.__name__
+        job_id = state.get("job_id", "unknown")
+        
+        # Log step start
+        workflow_logger.info(f"Starting step: {step_name} for job {job_id}")
+        
+        # Store the state before execution for comparison
+        before_state = {**state}
+        
+        try:
+            # Execute the step
+            result_state = func(state, *args, **kwargs)
+            
+            # Handle case when function returns None instead of state
+            if result_state is None:
+                workflow_logger.debug(f"Step {step_name} returned None; using original state.")
+                result_state = before_state
+            
+            # Update status to reflect step completion
+            if isinstance(result_state, dict) and "status" in result_state:
+                result_state["status"] = f"completed_{step_name}"
+            
+            # Log successful completion
+            workflow_logger.info(f"Completed step: {step_name} for job {job_id}")
+            
+            # Log state transitions
+            log_state_transition(before_state, result_state, step_name)
+            
+            return result_state
+            
+        except Exception as e:
+            # Log the exception with traceback
+            error_msg = f"Error in step {step_name}: {str(e)}"
+            workflow_logger.error(error_msg)
+            workflow_logger.error(traceback.format_exc())
+            
+            # Update state with error information
+            if "errors" not in state:
+                state["errors"] = []
+            
+            state["errors"].append({
+                "step": step_name,
+                "timestamp": datetime.now().isoformat(),
+                "error": str(e),
+                "traceback": traceback.format_exc()
+            })
+            
+            if "status" in state:
+                state["status"] = f"error_in_{step_name}"
+            
+            # Log state transition with error
+            log_state_transition(before_state, state, f"{step_name}_error")
+            
+            return state
+    
+    return wrapper
+
+def save_state_snapshot(state: Dict[str, Any], step: str) -> None:
+    """Save a snapshot of the current state to a JSON file"""
+    try:
+        # Create a timestamped filename
+        timestamp = datetime.now().strftime("%Y%m%d%H%M%S")
+        job_id = state.get("job_id", "unknown")
+        filename = f"{timestamp}_{job_id}_{step}.json"
+        
+        # Create the snapshots directory
+        snapshots_dir = os.path.join(settings.LOG_DIR, "snapshots")
+        os.makedirs(snapshots_dir, exist_ok=True)
+        
+        # Create a clean copy of the state (remove any objects that can't be serialized)
+        clean_state = {}
+        for key, value in state.items():
+            try:
+                # Test if it can be serialized
+                json.dumps({key: value})
+                clean_state[key] = value
+            except (TypeError, OverflowError):
+                clean_state[key] = f"<non-serializable: {type(value).__name__}>"
+        
+        # Write the state to file
+        with open(os.path.join(snapshots_dir, filename), 'w') as f:
+            json.dump(clean_state, f, indent=2, default=str)
+            
+        workflow_logger.debug(f"State snapshot saved: {filename}")
+    except Exception as e:
+        workflow_logger.error(f"Failed to save state snapshot: {str(e)}")