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

michael_agent/utils/monitor_utils.py

@@ -0,0 +1,289 @@
+"""
+Workflow monitoring utility for SmartRecruitAgent
+Provides tools to monitor and track workflow progress
+"""
+
+import os
+import json
+import time
+import logging
+import pandas as pd
+from typing import Dict, List, Optional
+from datetime import datetime, timedelta
+import matplotlib.pyplot as plt
+from tabulate import tabulate
+
+# Import config
+from config import settings
+
+# Configure logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+def load_log_entries(log_file_path: str, hours: int = 24) -> List[Dict]:
+    """Load log entries from the specified file, filtered by time range"""
+    if not os.path.exists(log_file_path):
+        logger.warning(f"Log file not found: {log_file_path}")
+        return []
+    
+    cutoff_time = datetime.now() - timedelta(hours=hours)
+    entries = []
+    
+    try:
+        with open(log_file_path, 'r') as f:
+            for line in f:
+                try:
+                    # Parse the log line to extract timestamp and JSON content
+                    parts = line.strip().split(' | ', 3)
+                    if len(parts) >= 4:
+                        timestamp_str = parts[0]
+                        log_level = parts[1]
+                        module = parts[2]
+                        message = parts[3]
+                        
+                        # Parse timestamp
+                        timestamp = datetime.strptime(timestamp_str, '%Y-%m-%d %H:%M:%S')
+                        
+                        # Skip entries older than cutoff time
+                        if timestamp < cutoff_time:
+                            continue
+                            
+                        # For state_transitions.log, message is a JSON string
+                        if 'state_transitions' in log_file_path:
+                            try:
+                                data = json.loads(message)
+                                data['timestamp'] = timestamp_str
+                                data['log_level'] = log_level
+                                entries.append(data)
+                            except json.JSONDecodeError:
+                                logger.debug(f"Failed to parse JSON: {message}")
+                        else:
+                            # For regular logs
+                            entries.append({
+                                'timestamp': timestamp_str,
+                                'log_level': log_level,
+                                'module': module,
+                                'message': message
+                            })
+                except Exception as e:
+                    logger.debug(f"Error parsing log line: {e}")
+                    continue
+    except Exception as e:
+        logger.error(f"Error reading log file {log_file_path}: {e}")
+    
+    return entries
+
+def load_state_snapshots(hours: int = 24) -> Dict[str, Dict]:
+    """Load state snapshots from the last specified hours"""
+    snapshots_dir = os.path.join(settings.LOG_DIR, "snapshots")
+    if not os.path.exists(snapshots_dir):
+        logger.warning(f"Snapshots directory not found: {snapshots_dir}")
+        return {}
+    
+    cutoff_time = datetime.now() - timedelta(hours=hours)
+    snapshots = {}
+    
+    try:
+        for filename in os.listdir(snapshots_dir):
+            if not filename.endswith('.json'):
+                continue
+                
+            filepath = os.path.join(snapshots_dir, filename)
+            file_mtime = datetime.fromtimestamp(os.path.getmtime(filepath))
+            
+            # Skip files older than cutoff time
+            if file_mtime < cutoff_time:
+                continue
+                
+            try:
+                with open(filepath, 'r') as f:
+                    data = json.load(f)
+                    snapshots[filename] = data
+            except Exception as e:
+                logger.debug(f"Error reading snapshot {filename}: {e}")
+    except Exception as e:
+        logger.error(f"Error accessing snapshots directory: {e}")
+    
+    return snapshots
+
+def generate_workflow_summary(hours: int = 24) -> pd.DataFrame:
+    """Generate a summary of workflow executions from the logs"""
+    workflow_logs = load_log_entries(os.path.join(settings.LOG_DIR, 'workflow.log'), hours)
+    
+    # Extract job IDs and create a summary
+    job_data = {}
+    for entry in workflow_logs:
+        message = entry.get('message', '')
+        
+        # Try to extract job ID from message
+        if '[Job ' in message:
+            parts = message.split('[Job ', 1)[1].split(']', 1)
+            if len(parts) >= 2:
+                job_id = parts[0].strip()
+                msg_content = parts[1].strip()
+                
+                if job_id not in job_data:
+                    job_data[job_id] = {
+                        'start_time': entry.get('timestamp'),
+                        'last_update': entry.get('timestamp'),
+                        'steps_completed': 0,
+                        'current_status': 'Unknown',
+                        'errors': 0
+                    }
+                
+                # Update job data
+                job_data[job_id]['last_update'] = entry.get('timestamp')
+                
+                if 'Step ' in msg_content:
+                    job_data[job_id]['steps_completed'] += 1
+                
+                if 'completed:' in msg_content:
+                    status = msg_content.split('completed:', 1)[1].strip()
+                    job_data[job_id]['current_status'] = status
+                
+                if 'Error' in message or 'error' in message:
+                    job_data[job_id]['errors'] += 1
+    
+    # Convert to DataFrame for easier display
+    if job_data:
+        df = pd.DataFrame.from_dict(job_data, orient='index')
+        df.index.name = 'job_id'
+        return df
+    else:
+        return pd.DataFrame(columns=['start_time', 'last_update', 'steps_completed', 'current_status', 'errors'])
+
+def display_errors(hours: int = 24) -> pd.DataFrame:
+    """Display all errors from the workflow logs"""
+    workflow_logs = load_log_entries(os.path.join(settings.LOG_DIR, 'workflow.log'), hours)
+    
+    error_entries = []
+    for entry in workflow_logs:
+        message = entry.get('message', '')
+        if entry.get('log_level') == 'ERROR' or 'Error' in message or 'error' in message:
+            # Try to extract job ID from message
+            job_id = 'Unknown'
+            if '[Job ' in message:
+                try:
+                    job_id = message.split('[Job ', 1)[1].split(']', 1)[0].strip()
+                except:
+                    pass
+                    
+            error_entries.append({
+                'timestamp': entry.get('timestamp'),
+                'job_id': job_id,
+                'error': message
+            })
+    
+    # Convert to DataFrame for easier display
+    if error_entries:
+        df = pd.DataFrame(error_entries)
+        return df
+    else:
+        return pd.DataFrame(columns=['timestamp', 'job_id', 'error'])
+
+def generate_job_timeline(job_id: str) -> Dict:
+    """Generate a timeline of steps for a specific job"""
+    workflow_logs = load_log_entries(os.path.join(settings.LOG_DIR, 'workflow.log'))
+    
+    timeline = []
+    for entry in workflow_logs:
+        message = entry.get('message', '')
+        if f'[Job {job_id}]' in message:
+            timestamp = entry.get('timestamp')
+            
+            # Extract step information if available
+            if 'Step ' in message and 'completed:' in message:
+                try:
+                    step_num = int(message.split('Step ', 1)[1].split(' ', 1)[0])
+                    step_name = message.split('completed:', 1)[1].strip()
+                    
+                    timeline.append({
+                        'timestamp': timestamp,
+                        'step_number': step_num,
+                        'step_name': step_name
+                    })
+                except:
+                    pass
+    
+    return sorted(timeline, key=lambda x: x.get('step_number', 0))
+
+def monitor_active_jobs():
+    """Display a summary of active jobs in the terminal"""
+    print("\n" + "="*80)
+    print(" SmartRecruitAgent Workflow Monitor ".center(80, "="))
+    print("="*80)
+    
+    # Get workflow summary
+    df = generate_workflow_summary(hours=24)
+    
+    if df.empty:
+        print("\nNo active jobs found in the last 24 hours.")
+    else:
+        # Calculate job duration
+        df['duration'] = pd.to_datetime(df['last_update']) - pd.to_datetime(df['start_time'])
+        df['duration'] = df['duration'].astype(str).str.split('.').str[0]  # Format duration
+        
+        # Format the output
+        summary_df = df[['start_time', 'duration', 'steps_completed', 'current_status', 'errors']].copy()
+        print(f"\nActive Jobs (Last 24 Hours): {len(summary_df)}")
+        print(tabulate(summary_df, headers='keys', tablefmt='grid'))
+    
+    # Display recent errors
+    error_df = display_errors(hours=6)
+    if not error_df.empty:
+        print("\nRecent Errors (Last 6 Hours):")
+        print(tabulate(error_df, headers='keys', tablefmt='grid', maxcolwidths=[20, 10, 50]))
+    
+    print("\n" + "="*80)
+
+def show_job_details(job_id: str):
+    """Show detailed information for a specific job"""
+    timeline = generate_job_timeline(job_id)
+    
+    print("\n" + "="*80)
+    print(f" Job Details: {job_id} ".center(80, "="))
+    print("="*80)
+    
+    if not timeline:
+        print(f"\nNo data found for job ID: {job_id}")
+        return
+        
+    # Print timeline
+    print("\nExecution Timeline:")
+    for step in timeline:
+        print(f"[{step['timestamp']}] Step {step['step_number']}: {step['step_name']}")
+    
+    # Look for snapshots for this job
+    snapshots = load_state_snapshots()
+    job_snapshots = {k: v for k, v in snapshots.items() if job_id in k}
+    
+    if job_snapshots:
+        print("\nState Snapshots Available:")
+        for filename in job_snapshots:
+            print(f" - {filename}")
+            
+        # Print the latest snapshot details
+        latest = max(job_snapshots.keys())
+        print(f"\nLatest State ({latest}):")
+        snapshot = job_snapshots[latest]
+        
+        # Print key information
+        if 'candidate_name' in snapshot:
+            print(f"Candidate: {snapshot.get('candidate_name', 'Unknown')}")
+        if 'candidate_email' in snapshot:
+            print(f"Email: {snapshot.get('candidate_email', 'Unknown')}")
+        if 'resume_path' in snapshot:
+            print(f"Resume: {snapshot.get('resume_path', 'Unknown')}")
+        if 'relevance_score' in snapshot and snapshot['relevance_score'] is not None:
+            print(f"Relevance Score: {snapshot.get('relevance_score', 'N/A')}")
+        
+        # Print any errors
+        if 'errors' in snapshot and snapshot['errors']:
+            print("\nErrors:")
+            for error in snapshot['errors']:
+                print(f" - [{error.get('step', 'unknown')}] {error.get('error', 'Unknown error')}")
+    
+    print("\n" + "="*80)
+
+if __name__ == "__main__":
+    monitor_active_jobs()

michael_agent/utils/node_tracer.py

@@ -0,0 +1,88 @@
+"""
+Utility to apply logging decorators to workflow nodes
+Ensures consistent logging across all workflow steps
+"""
+
+import os
+import sys
+import inspect
+import logging
+import importlib
+from types import ModuleType
+from typing import Dict, Any, Callable
+from functools import wraps
+
+# Import our logging decorator
+from utils.logging_utils import log_step, workflow_logger as logger
+
+def trace_node(node_function: Callable) -> Callable:
+    """Apply tracing to a node function"""
+    # First, apply our standard logging decorator
+    traced_function = log_step(node_function)
+    
+    @wraps(node_function)
+    def wrapper(state: Dict[str, Any], *args, **kwargs) -> Dict[str, Any]:
+        # Get the job ID for logging
+        job_id = state.get("job_id", "unknown")
+        logger.debug(f"[Job {job_id}] Entering node {node_function.__name__}")
+        
+        try:
+            # Call the decorated function
+            result = traced_function(state, *args, **kwargs)
+            return result
+        except Exception as e:
+            # Log the error and re-raise it (our decorator will handle it)
+            logger.error(f"[Job {job_id}] Exception in {node_function.__name__}: {str(e)}")
+            raise
+    
+    return wrapper
+
+def trace_workflow_nodes():
+    """Apply tracing to all workflow nodes"""
+    # Define the base path to our nodes directory
+    nodes_dir = os.path.join(os.path.dirname(__file__), '..', 'langgraph_workflow', 'nodes')
+    sys.path.append(os.path.abspath(os.path.join(nodes_dir, '..')))
+    
+    nodes_path = 'langgraph_workflow.nodes'
+    logger.info(f"Applying tracing to workflow nodes in {nodes_path}")
+    
+    # Get all Python files in the nodes directory (excluding __init__ and __pycache__)
+    node_modules = []
+    for filename in os.listdir(nodes_dir):
+        if (filename.endswith('.py') and 
+            filename != '__init__.py' and 
+            not filename.startswith('__')):
+            module_name = filename[:-3]  # Remove .py extension
+            node_modules.append(module_name)
+    
+    # Apply tracing to node functions in each module
+    for module_name in node_modules:
+        full_module_name = f"{nodes_path}.{module_name}"
+        try:
+            # Import the module
+            module = importlib.import_module(full_module_name)
+            
+            # Find all functions in the module that might be node functions
+            traced_count = 0
+            for name, obj in inspect.getmembers(module):
+                if (inspect.isfunction(obj) and 
+                    not name.startswith('_') and
+                    'state' in inspect.signature(obj).parameters):
+                    
+                    # This looks like a node function, apply tracing
+                    original_function = obj
+                    traced_function = trace_node(original_function)
+                    
+                    # Replace the original function with our traced version
+                    setattr(module, name, traced_function)
+                    traced_count += 1
+            
+            logger.info(f"Applied tracing to {traced_count} functions in {full_module_name}")
+            
+        except Exception as e:
+            logger.error(f"Error applying tracing to {full_module_name}: {str(e)}")
+    
+    logger.info("Tracing applied to all workflow nodes")
+
+# Apply tracing automatically when this module is imported
+trace_workflow_nodes()

{michael_agent-1.0.0.dist-info → michael_agent-1.0.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: michael_agent
-Version: 1.0.0
+Version: 1.0.2
 Summary: SmartRecruitAgent - A recruitment automation library
 Home-page: https://github.com/yourusername/agent
 Author: Michael Jone
@@ -8,7 +8,7 @@ Author-email: your_email@example.com
 Classifier: Programming Language :: Python :: 3
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: OS Independent
-Requires-Python: >=3.7
+Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 Requires-Dist: python-dotenv
 Requires-Dist: langchain

michael_agent-1.0.2.dist-info/RECORD

@@ -0,0 +1,32 @@
+michael_agent/__init__.py,sha256=prEeI3mdpO8R5QTpniRR_Tl21uqF7pGJHwBidQ9JIKQ,179
+michael_agent/main.py,sha256=j5BXOxg_8YE-bnu3cKrylQCHCssZ6PP4UbGorRVJMd4,3385
+michael_agent/monitor.py,sha256=RThpdPW7lf5zI3ilMShVeDf4Vao5Yq0E4Rao9uuS9XY,2473
+michael_agent/config/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+michael_agent/config/settings.py,sha256=_4uvWQnMscK01Sd0zT5wesVW5uN0njtKYRMsjMQXEOY,3180
+michael_agent/dashboard/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+michael_agent/dashboard/app.py,sha256=UtMswD7TGGJBY9cMeuFQPJAtgaRiXFso6PsTHtvPGN8,61963
+michael_agent/dashboard/static/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+michael_agent/dashboard/templates/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+michael_agent/langgraph_workflow/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+michael_agent/langgraph_workflow/graph_builder.py,sha256=xdsZ_lVWFn5B8xNXg_L49H-Jwfj-p7nxPVOwtc9Rf2U,14487
+michael_agent/langgraph_workflow/nodes/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+michael_agent/langgraph_workflow/nodes/assessment_handler.py,sha256=qgMB8fJdyA2CP8VWY2m-7-418LcY302S-SR_JHamSTE,6401
+michael_agent/langgraph_workflow/nodes/jd_generator.py,sha256=G8cM3NkGqd44iUAbJJDed9kFjJ-F02_FXB6I_7AE_kA,5105
+michael_agent/langgraph_workflow/nodes/jd_poster.py,sha256=6F1jQRG_IoiopIOpIDjSpuCE3I6_A7-ZEMkV8FtKXQs,4550
+michael_agent/langgraph_workflow/nodes/question_generator.py,sha256=XgDc5f7-ifsJ3UdzB22NjKMqjUcG2_elTZ5LOPGVkt8,11670
+michael_agent/langgraph_workflow/nodes/recruiter_notifier.py,sha256=xLVhRP1I-QIcO_b0lYLuMnMTpGHAFakG-luPJrhkN6Y,8522
+michael_agent/langgraph_workflow/nodes/resume_analyzer.py,sha256=XG4MksqSqhhNwGSfDauIbEpPmxogDJ6skJgR-xpeY0g,24027
+michael_agent/langgraph_workflow/nodes/resume_ingestor.py,sha256=h14J4AcFk22BWoFHCPRkK3HpzY8RvwGW6_jjqBxLXNU,9279
+michael_agent/langgraph_workflow/nodes/sentiment_analysis.py,sha256=H-geV4AbFbt1EpiLKnpaXdvrrjjXMN-Dzzg4sZOjhdM,11657
+michael_agent/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+michael_agent/utils/email_utils.py,sha256=PsL3QTQuV_iVou_2Y3o_Dohz7tN9YNp9FPxsTKkDRv0,4989
+michael_agent/utils/id_mapper.py,sha256=GzYRuAhGWf2BUAb9hVMS3KR8bmYExnmXRWkQ_j-kWaw,397
+michael_agent/utils/jd_utils.py,sha256=OqzI0os3sIssa-L_-SrMe901yzjE0Z_zllztYNKReZ4,1234
+michael_agent/utils/lms_api.py,sha256=tmntU6tjyAdMLak_vfoxBkWNIPUKvejeEwb2t6yQBUM,8436
+michael_agent/utils/logging_utils.py,sha256=Ld7fs2uuCOM0bx-totxHzKzKHl5lfAe3TXeH1QYJBjw,7179
+michael_agent/utils/monitor_utils.py,sha256=1Ig6C79bQ_OOLKhgFNmm0ybntQavqzyJ3zsxD0iZxxw,11069
+michael_agent/utils/node_tracer.py,sha256=N1MWly4qfzh87Fo1xRS5hpefoAvfSyZIPvMOegPrtBY,3411
+michael_agent-1.0.2.dist-info/METADATA,sha256=4mAZuyRUC_RoCuQdFpaJnXK1kVSsTnqN36dFwRyPYE8,1340
+michael_agent-1.0.2.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+michael_agent-1.0.2.dist-info/top_level.txt,sha256=-r35JOIHnK3RsMhJ77tDKfWtmfGDr_iT2642k-suUDo,14
+michael_agent-1.0.2.dist-info/RECORD,,

michael_agent-1.0.0.dist-info/RECORD

@@ -1,7 +0,0 @@
-michael_agent/__init__.py,sha256=prEeI3mdpO8R5QTpniRR_Tl21uqF7pGJHwBidQ9JIKQ,179
-michael_agent/main.py,sha256=j5BXOxg_8YE-bnu3cKrylQCHCssZ6PP4UbGorRVJMd4,3385
-michael_agent/monitor.py,sha256=RThpdPW7lf5zI3ilMShVeDf4Vao5Yq0E4Rao9uuS9XY,2473
-michael_agent-1.0.0.dist-info/METADATA,sha256=KRL2sOmwfc4WDlyLbDWRZX3UMtWSLHoJ20LBofSHsLY,1339
-michael_agent-1.0.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-michael_agent-1.0.0.dist-info/top_level.txt,sha256=-r35JOIHnK3RsMhJ77tDKfWtmfGDr_iT2642k-suUDo,14
-michael_agent-1.0.0.dist-info/RECORD,,