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

michael_agent/langgraph_workflow/nodes/resume_ingestor.py

@@ -0,0 +1,225 @@
+"""
+Resume Ingestor Node
+Watches for new resumes from local directory
+"""
+
+import os
+import logging
+import shutil
+import time
+import atexit
+import json
+from typing import Dict, Any, Optional
+from watchdog.observers import Observer
+from watchdog.events import FileSystemEventHandler
+
+# Import config
+from config import settings
+
+# Configure logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+# Global variable for watchdog observer
+_global_observer = None
+
+# Global variable for watchdog observer
+_global_observer = None
+
+class ResumeFileHandler(FileSystemEventHandler):
+    """File system event handler for monitoring new resume files"""
+    
+    def __init__(self, callback_fn):
+        self.callback_fn = callback_fn
+        self.extensions = ['.pdf', '.docx', '.doc', '.txt']
+        
+    def on_created(self, event):
+        if not event.is_directory:
+            file_path = event.src_path
+            if any(file_path.lower().endswith(ext) for ext in self.extensions):
+                logger.info(f"New resume detected: {file_path}")
+                self.callback_fn(file_path)
+
+def setup_watcher(watch_dir: str, callback_fn):
+    """Set up a file system watcher for the specified directory"""
+    observer = Observer()
+    event_handler = ResumeFileHandler(callback_fn)
+    observer.schedule(event_handler, watch_dir, recursive=False)
+    observer.start()
+    
+    # Store in global variable for cleanup
+    global _global_observer
+    _global_observer = observer
+    
+    return observer
+
+def copy_resume_to_output(resume_path: str) -> str:
+    """Copy the resume to the output directory"""
+    try:
+        # Ensure output directory exists
+        os.makedirs(settings.OUTPUT_DIR, exist_ok=True)
+        
+        # Copy the file to output directory
+        filename = os.path.basename(resume_path)
+        output_path = os.path.join(settings.OUTPUT_DIR, filename)
+        shutil.copy2(resume_path, output_path)
+        
+        # Return the path to the copied file
+        return output_path
+    except Exception as e:
+        logger.error(f"Error copying resume to output: {str(e)}")
+        raise
+
+def ingest_resume(state: Dict[str, Any]) -> Dict[str, Any]:
+    """Ingest new resumes for processing from the local file system"""
+    try:
+        # Check if this is just a setup call without processing existing files
+        setup_only = state.get("setup_only", False)
+        
+        # Check if we already have a resume path in the state
+        if state.get("resume_path") and not setup_only:
+            logger.info(f"Processing resume from state: {state.get('resume_path')}")
+            resume_path = state.get("resume_path")
+            
+            # Copy to output directory if it exists and is not already there
+            if os.path.exists(resume_path) and not resume_path.startswith(settings.OUTPUT_DIR):
+                output_path = copy_resume_to_output(resume_path)
+                # Update the path to point to the copied file
+                state["resume_path"] = output_path
+                logger.info(f"Copied resume to output directory: {output_path}")
+            
+            # Move on with the workflow
+            return state
+        
+        # Ensure output directory exists
+        os.makedirs(settings.OUTPUT_DIR, exist_ok=True)
+        
+        # Ensure log directory exists
+        os.makedirs(settings.LOG_DIR, exist_ok=True)
+        
+        # Set up local file system watcher if not already running
+        if 'resume_watcher' not in state or not state['resume_watcher']:
+            # Create the watch directory if it doesn't exist
+            os.makedirs(settings.RESUME_WATCH_DIR, exist_ok=True)
+            
+            # Process any existing files in the directory (skip if setup_only)
+            if not setup_only:
+                for filename in os.listdir(settings.RESUME_WATCH_DIR):
+                    file_path = os.path.join(settings.RESUME_WATCH_DIR, filename)
+                    if os.path.isfile(file_path) and any(file_path.lower().endswith(ext) for ext in ['.pdf', '.docx', '.doc', '.txt']) and not filename.endswith('.json'):
+                        logger.info(f"Processing existing resume: {file_path}")
+                        output_path = copy_resume_to_output(file_path)
+                        if 'resumes' not in state:
+                            state['resumes'] = []
+                        state['resumes'].append({
+                            'filename': os.path.basename(file_path),
+                            'path': output_path,
+                            'status': 'received'
+                        })
+                        
+                        # Automatically trigger workflow for this resume
+                        from langgraph_workflow.graph_builder import process_new_resume
+                        try:
+                            process_new_resume(file_path)
+                            logger.info(f"Triggered workflow for existing resume: {file_path}")
+                        except Exception as e:
+                            logger.error(f"Failed to trigger workflow for existing resume {file_path}: {str(e)}")
+            else:
+                logger.info("Setup only mode - skipping processing of existing files")
+            
+            # Set up the watcher for future files
+            def process_new_file(file_path):
+                logger.info(f"New resume detected: {file_path}")
+                output_path = copy_resume_to_output(file_path)
+                # Update the state (in a real app, you'd need proper concurrency handling)
+                if 'resumes' not in state:
+                    state['resumes'] = []
+                state['resumes'].append({
+                    'filename': os.path.basename(file_path),
+                    'path': output_path,
+                    'status': 'received'
+                })
+                
+                # Automatically trigger workflow for this resume, specifying resume_ingestor as the entry point
+                from langgraph_workflow.graph_builder import process_new_resume
+                try:
+                    process_new_resume(file_path)
+                    logger.info(f"Triggered workflow for new resume: {file_path}")
+                except Exception as e:
+                    logger.error(f"Failed to trigger workflow for new resume {file_path}: {str(e)}")
+            
+            # Start the watcher
+            observer = setup_watcher(settings.RESUME_WATCH_DIR, process_new_file)
+            state['resume_watcher'] = observer
+        
+        return state
+    except Exception as e:
+        logger.error(f"Error in resume ingestion: {str(e)}")
+        # Add error to state
+        if 'errors' not in state:
+            state['errors'] = []
+        state['errors'].append(f"Resume ingestion error: {str(e)}")
+        return state
+
+def extract_job_id_from_filename(filename: str) -> str:
+    """Extract job ID from the resume filename"""
+    try:
+        # Assuming the job ID is the first part of the filename, before an underscore
+        job_id = os.path.basename(filename).split('_')[0]
+        logger.info(f"Extracted job ID {job_id} from filename {filename}")
+        return job_id
+    except Exception as e:
+        logger.error(f"Error extracting job ID from filename {filename}: {str(e)}")
+        return ""
+
+def process_resume(file_path: str, state: Dict[str, Any] = None) -> Dict[str, Any]:
+    """
+    Process a resume file
+    """
+    logger.info(f"Processing resume from state: {file_path}")
+    
+    # Extract job ID from filename (e.g., 20250626225207_Michael_Jone.pdf)
+    try:
+        job_id = extract_job_id_from_filename(file_path)
+        logger.info(f"Extracted job ID from filename: {job_id}")
+        
+        # Update state with the extracted job ID
+        if state is None:
+            state = {}
+        state["job_id"] = job_id
+        logger.info(f"Updated state with job ID: {job_id}")
+    except Exception as e:
+        logger.error(f"Failed to extract job ID from filename: {e}")
+    
+    # Copy resume to processed directory
+    output_dir = "./processed_resumes"
+    os.makedirs(output_dir, exist_ok=True)
+    
+    # Get just the filename without path
+    filename = os.path.basename(file_path)
+    output_path = os.path.join(output_dir, filename)
+    
+    shutil.copy(file_path, output_path)
+    logger.info(f"Copied resume to output directory: {output_path}")
+    
+    # Return updated state with resume path and job_id
+    return {
+        "status": "completed_ingest_resume",
+        "resume_path": output_path,
+        "job_id": job_id
+    }
+
+def cleanup(state: Dict[str, Any]) -> None:
+    """Clean up resources when shutting down"""
+    try:
+        if 'resume_watcher' in state and state['resume_watcher']:
+            logger.info("Stopping resume watcher...")
+            state['resume_watcher'].stop()
+            state['resume_watcher'].join(timeout=5.0)  # Wait up to 5 seconds for clean shutdown
+            logger.info("Resume watcher stopped")
+    except Exception as e:
+        logger.error(f"Error stopping resume watcher: {str(e)}")
+        
+# Register cleanup function to be called on program exit
+import atexit
+atexit.register(lambda: cleanup({'resume_watcher': globals().get('_global_observer')}))

michael_agent/langgraph_workflow/nodes/sentiment_analysis.py

@@ -0,0 +1,309 @@
+"""
+Sentiment Analysis Node
+Analyzes cover letters for sentiment using Azure OpenAI
+"""
+
+import os
+import logging
+from typing import Dict, Any, List, Optional
+import json
+
+# Try to import Azure OpenAI
+try:
+    from langchain_openai import AzureChatOpenAI, AzureOpenAIEmbeddings
+    from langchain_core.messages import HumanMessage
+    import numpy as np
+    from sklearn.metrics.pairwise import cosine_similarity
+    OPENAI_AVAILABLE = True
+except ImportError:
+    OPENAI_AVAILABLE = False
+
+# Import config
+from config import settings
+
+# Configure logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+def create_azure_openai_client():
+    """Create and configure the Azure OpenAI client"""
+    if not OPENAI_AVAILABLE:
+        logger.warning("Azure OpenAI not available. Install with 'pip install langchain-openai'")
+        return None
+    
+    try:
+        # Use the correct parameter names for Azure OpenAI
+        api_key = settings.AZURE_OPENAI_API_KEY or settings.AZURE_OPENAI_KEY or settings.OPENAI_API_KEY
+        endpoint = settings.AZURE_OPENAI_ENDPOINT or settings.OPENAI_API_BASE
+        api_version = settings.AZURE_OPENAI_API_VERSION or settings.OPENAI_API_VERSION
+        deployment = settings.AZURE_OPENAI_DEPLOYMENT
+        
+        return AzureChatOpenAI(
+            azure_deployment=deployment,  # Use azure_deployment parameter
+            api_version=api_version,
+            azure_endpoint=endpoint,  # Use azure_endpoint instead of openai_api_base
+            api_key=api_key
+        )
+    except Exception as e:
+        logger.error(f"Error initializing Azure OpenAI client: {str(e)}")
+        return None
+
+def create_embeddings_client():
+    """
+    This function is no longer used as we've removed the embedding-based approach.
+    It's kept for backward compatibility but now returns None.
+    """
+    logger.info("Embeddings client creation skipped - using direct LLM approach instead")
+    return None
+
+def extract_cover_letter(resume_text: str) -> Optional[str]:
+    """Extract cover letter text from resume text"""
+    # This is a very basic implementation - in practice, you'd need more sophisticated logic
+    
+    # Look for "cover letter" or "letter of interest" in the text
+    lines = resume_text.lower().split('\n')
+    cover_letter_text = None
+    
+    for i, line in enumerate(lines):
+        if "cover letter" in line or "letter of interest" in line or "dear hiring" in line:
+            # Extract next 20 lines as the potential cover letter
+            potential_cover_letter = "\n".join(lines[i:i+20])
+            if len(potential_cover_letter) > 100:  # Only use if it's substantial
+                cover_letter_text = potential_cover_letter
+                break
+    
+    return cover_letter_text
+
+def analyze_text_sentiment_openai_chat(client, text: str) -> Dict[str, Any]:
+    """
+    Analyze text sentiment using Azure OpenAI Chat
+    Args:
+        client: Azure OpenAI client
+        text: Text to analyze
+    Returns:
+        Sentiment analysis result
+    """
+    try:
+        # Create the prompt
+        prompt = f"""
+        Analyze the sentiment of the following text. Respond with a JSON object containing:
+        - sentiment: either "positive", "neutral", or "negative"
+        - positive_score: a float between 0 and 1
+        - neutral_score: a float between 0 and 1
+        - negative_score: a float between 0 and 1
+        - sentences: the number of sentences in the text
+        
+        Here's the text to analyze:
+        
+        {text}
+        """
+        
+        # Get the response from Azure OpenAI
+        response = client.invoke([HumanMessage(content=prompt)])
+        
+        # Parse the response as JSON
+        try:
+            content = response.content
+            # Extract JSON if it's wrapped in markdown code blocks
+            if "```json" in content and "```" in content:
+                json_part = content.split("```json")[1].split("```")[0].strip()
+                sentiment_data = json.loads(json_part)
+            else:
+                sentiment_data = json.loads(content)
+        except json.JSONDecodeError:
+            # If response is not valid JSON, extract key values using simple parsing
+            content = response.content.lower()
+            sentiment = "positive" if "positive" in content else "negative" if "negative" in content else "neutral"
+            return {
+                "sentiment": sentiment,
+                "positive_score": 0.33,
+                "neutral_score": 0.34,
+                "negative_score": 0.33,
+                "sentences": len(text.split('.')),
+                "parsing_method": "fallback"
+            }
+        
+        return {
+            "sentiment": sentiment_data.get("sentiment", "neutral"),
+            "positive_score": sentiment_data.get("positive_score", 0.33),
+            "neutral_score": sentiment_data.get("neutral_score", 0.34),
+            "negative_score": sentiment_data.get("negative_score", 0.33),
+            "sentences": sentiment_data.get("sentences", len(text.split('.'))),
+            "parsing_method": "json"
+        }
+    except Exception as e:
+        logger.error(f"Error analyzing sentiment with Azure OpenAI Chat: {str(e)}")
+        return {
+            "sentiment": "neutral",
+            "positive_score": 0.33,
+            "neutral_score": 0.34,
+            "negative_score": 0.33,
+            "sentences": len(text.split('.')),
+            "error": str(e),
+        }
+
+def analyze_text_sentiment_embeddings(client, text: str) -> Dict[str, Any]:
+    """
+    This function is kept for backward compatibility but redirects to using the chat-based sentiment analysis
+    as we've removed the embedding approach
+    """
+    logger.info("Embeddings-based sentiment analysis has been removed, using chat-based analysis instead")
+    
+    # Try to get a chat client and use that instead
+    chat_client = create_azure_openai_client()
+    if chat_client:
+        return analyze_text_sentiment_openai_chat(chat_client, text)
+    else:
+        # Fall back to basic analysis if chat client creation fails
+        return analyze_text_sentiment_basic(text)
+
+def analyze_text_sentiment_basic(text: str) -> Dict[str, Any]:
+    """Basic sentiment analysis without Azure services"""
+    # This is a very simplified sentiment analysis - in practice, use a proper NLP library
+    positive_words = ['excellent', 'good', 'great', 'best', 'outstanding', 'impressive', 
+                      'excited', 'passion', 'enthusiastic', 'enjoy', 'love', 'interested', 
+                      'committed', 'dedicated', 'eager']
+    
+    negative_words = ['unfortunately', 'bad', 'worst', 'poor', 'difficult', 'challenge', 
+                      'issue', 'problem', 'concern', 'disappointed', 'regret', 'sorry']
+    
+    text_lower = text.lower()
+    
+    # Count occurrences of positive and negative words
+    positive_count = sum(text_lower.count(word) for word in positive_words)
+    negative_count = sum(text_lower.count(word) for word in negative_words)
+    total = positive_count + negative_count
+    
+    # Calculate sentiment scores
+    if total == 0:
+        return {
+            "sentiment": "neutral",
+            "positive_score": 0.33,
+            "neutral_score": 0.34,
+            "negative_score": 0.33,
+            "sentences": len(text.split('.')),
+            "method": "basic"
+        }
+    
+    positive_score = positive_count / total if total > 0 else 0.33
+    negative_score = negative_count / total if total > 0 else 0.33
+    neutral_score = 1 - (positive_score + negative_score)
+    
+    # Determine sentiment
+    if positive_score > 0.6:
+        sentiment = "positive"
+    elif negative_score > 0.6:
+        sentiment = "negative"
+    else:
+        sentiment = "neutral"
+    
+    return {
+        "sentiment": sentiment,
+        "positive_score": positive_score,
+        "neutral_score": neutral_score,
+        "negative_score": negative_score,
+        "sentences": len(text.split('.')),
+        "method": "basic"
+    }
+
+def analyze_sentiment(state: Dict[str, Any]) -> Dict[str, Any]:
+    """
+    LangGraph node to analyze sentiment of cover letters using Azure OpenAI
+    
+    Args:
+        state: The current workflow state
+        
+    Returns:
+        Updated workflow state with sentiment analysis
+    """
+    logger.info("Starting sentiment analysis with Azure OpenAI")
+    
+    # Initialize errors list if not present
+    if "errors" not in state:
+        state["errors"] = []
+    
+    # Check if sentiment score already exists in state
+    if state.get("sentiment_score") is not None:
+        logger.info("Sentiment already analyzed, skipping analysis")
+        return state
+    
+    # Check if resume text exists
+    resume_text = state.get("resume_text")
+    if not resume_text:
+        error_message = "Missing resume text for sentiment analysis"
+        logger.error(error_message)
+        
+        # Add error to state
+        state["errors"].append({
+            "step": "sentiment_analysis",
+            "error": error_message
+        })
+        
+        # Set default sentiment
+        state["sentiment_score"] = {
+            "sentiment": "neutral",
+            "positive_score": 0.33,
+            "neutral_score": 0.34,
+            "negative_score": 0.33,
+            "available": False
+        }
+        return state
+    
+    try:
+        # Extract cover letter
+        cover_letter = extract_cover_letter(resume_text)
+        
+        # If no cover letter found, use the first 1000 characters of resume as a sample
+        sample_text = cover_letter if cover_letter else resume_text[:1000]
+        
+        # Initialize clients and results
+        sentiment_result = None
+        chat_client = None
+        
+        # Try to create Azure OpenAI client for chat if available
+        if OPENAI_AVAILABLE and (settings.AZURE_OPENAI_API_KEY or settings.AZURE_OPENAI_KEY):
+            chat_client = create_azure_openai_client()
+            # We no longer use embeddings, so don't initialize that client
+        
+        # Only use chat-based or basic sentiment analysis
+        if chat_client:
+            # Method 1: Use Azure OpenAI Chat for sentiment analysis
+            sentiment_result = analyze_text_sentiment_openai_chat(chat_client, sample_text)
+            logger.info("Used Azure OpenAI Chat for sentiment analysis")
+        else:
+            # Fallback: Basic sentiment analysis
+            sentiment_result = analyze_text_sentiment_basic(sample_text)
+            logger.info("Used basic sentiment analysis (Azure services unavailable)")
+        
+        # Add additional context
+        sentiment_result["cover_letter_available"] = True if cover_letter else False
+        sentiment_result["text_used"] = "cover_letter" if cover_letter else "resume_sample"
+        sentiment_result["available"] = True
+        
+        # Update state
+        state["sentiment_score"] = sentiment_result
+        state["status"] = "sentiment_analyzed"
+        
+        logger.info(f"Sentiment analyzed successfully: {sentiment_result['sentiment']}")
+        
+    except Exception as e:
+        error_message = f"Error analyzing sentiment: {str(e)}"
+        logger.error(error_message)
+        
+        # Add error to state
+        state["errors"].append({
+            "step": "sentiment_analysis",
+            "error": error_message
+        })
+        
+        # Set default sentiment
+        state["sentiment_score"] = {
+            "sentiment": "neutral",
+            "positive_score": 0.33,
+            "neutral_score": 0.34,
+            "negative_score": 0.33,
+            "available": False,
+            "error": str(e)
+        }
+    
+    return state

michael_agent/utils/email_utils.py

@@ -0,0 +1,140 @@
+"""
+Email utilities for sending notifications using SMTP or Azure Communication Services
+"""
+
+import os
+import smtplib
+import logging
+from email.mime.text import MIMEText
+from email.mime.multipart import MIMEMultipart
+from email.mime.application import MIMEApplication
+
+# Try to import Azure Communication Services
+try:
+    from azure.communication.email import EmailClient
+    AZURE_EMAIL_AVAILABLE = True
+except ImportError:
+    AZURE_EMAIL_AVAILABLE = False
+
+from config import settings
+
+logger = logging.getLogger(__name__)
+
+def send_email_smtp(recipient_email, subject, body, html_content=None, attachments=None):
+    """
+    Send an email using SMTP protocol
+    
+    Args:
+        recipient_email: The recipient's email address
+        subject: Email subject
+        body: Plain text email body
+        html_content: Optional HTML content
+        attachments: List of file paths to attach
+        
+    Returns:
+        True if sent successfully, False otherwise
+    """
+    try:
+        # Create a multipart message
+        msg = MIMEMultipart('alternative')
+        msg['Subject'] = subject
+        msg['From'] = settings.EMAIL_SENDER
+        msg['To'] = recipient_email
+        
+        # Add plain text content
+        msg.attach(MIMEText(body, 'plain'))
+        
+        # Add HTML content if provided
+        if html_content:
+            msg.attach(MIMEText(html_content, 'html'))
+        
+        # Add attachments if provided
+        if attachments:
+            for file_path in attachments:
+                with open(file_path, 'rb') as file:
+                    part = MIMEApplication(file.read(), Name=os.path.basename(file_path))
+                    part['Content-Disposition'] = f'attachment; filename="{os.path.basename(file_path)}"'
+                    msg.attach(part)
+        
+        # Connect to SMTP server and send email
+        with smtplib.SMTP(settings.SMTP_SERVER, settings.SMTP_PORT) as server:
+            server.ehlo()
+            server.starttls()
+            server.login(settings.SMTP_USERNAME, settings.SMTP_PASSWORD)
+            server.send_message(msg)
+            
+        logger.info(f"Email sent to {recipient_email} with subject '{subject}'")
+        return True
+    except Exception as e:
+        logger.error(f"Error sending email via SMTP: {str(e)}")
+        return False
+
+def send_email_azure(recipient_email, subject, body, html_content=None):
+    """
+    Send an email using Azure Communication Services
+    
+    Args:
+        recipient_email: The recipient's email address
+        subject: Email subject
+        body: Plain text email body
+        html_content: Optional HTML content
+        
+    Returns:
+        True if sent successfully, False otherwise
+    """
+    if not AZURE_EMAIL_AVAILABLE:
+        logger.error("Azure Communication Services not available. Install with 'pip install azure-communication-email'")
+        return False
+    
+    try:
+        # Create the email client
+        email_client = EmailClient.from_connection_string(settings.AZURE_COMMUNICATION_CONNECTION_STRING)
+        
+        # Use HTML content if provided, otherwise use plain text
+        content = html_content if html_content else body
+        content_type = "html" if html_content else "plainText"
+        
+        # Create the email message
+        message = {
+            "senderAddress": settings.AZURE_COMMUNICATION_SENDER_EMAIL,
+            "recipients": {
+                "to": [{"address": recipient_email}]
+            },
+            "content": {
+                "subject": subject,
+                "plainText": body,
+                "html": content if content_type == "html" else None
+            }
+        }
+        
+        # Send the email
+        poller = email_client.begin_send(message)
+        result = poller.result()
+        
+        logger.info(f"Email sent to {recipient_email} with subject '{subject}' via Azure Communication Services")
+        return True
+    except Exception as e:
+        logger.error(f"Error sending email via Azure Communication Services: {str(e)}")
+        return False
+
+def send_email(recipient_email, subject, body, html_content=None, attachments=None, use_azure=False):
+    """
+    Send an email using the preferred method (SMTP or Azure Communication Services)
+    
+    Args:
+        recipient_email: The recipient's email address
+        subject: Email subject
+        body: Plain text email body
+        html_content: Optional HTML content
+        attachments: List of file paths to attach (only used with SMTP)
+        use_azure: Force using Azure Communication Services if available
+        
+    Returns:
+        True if sent successfully, False otherwise
+    """
+    # Use Azure if requested and available
+    if use_azure and AZURE_EMAIL_AVAILABLE and settings.AZURE_COMMUNICATION_CONNECTION_STRING:
+        return send_email_azure(recipient_email, subject, body, html_content)
+    
+    # Fall back to SMTP
+    return send_email_smtp(recipient_email, subject, body, html_content, attachments)

michael_agent/utils/id_mapper.py

@@ -0,0 +1,14 @@
+import os
+import json
+import logging
+from typing import Optional, List, Dict
+
+logger = logging.getLogger(__name__)
+
+def get_timestamp_id(job_id: str) -> str:
+    """For backward compatibility: return the same job_id"""
+    return job_id
+    
+def get_all_ids_for_timestamp(timestamp_id: str) -> List[str]:
+    """For backward compatibility: return list with same job_id"""
+    return [timestamp_id]