functions/job_call.py

'''Functions for summarizing and formatting job calls.'''

import os
import json
import logging
from pathlib import Path
from datetime import datetime
from openai import OpenAI
from configuration import JOB_CALL_EXTRACTION_PROMPT

# pylint: disable=broad-exception-caught

# Set up logging
logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)


def load_default_job_call() -> str:
    """
    Load default job call text from data/sample_job.txt if it exists.

    Returns:
        str: The default job call text, or empty string if file doesn't exist
    """
    try:
        # Get the project root directory (parent of functions directory)
        project_root = Path(__file__).parent.parent
        default_job_path = project_root / "data" / "sample_job.txt"

        if default_job_path.exists():
            with open(default_job_path, 'r', encoding='utf-8') as f:
                job_text = f.read().strip()

            logger.info("Loaded default job call from: %s (%d characters)",
                       default_job_path, len(job_text))
            return job_text
        else:
            logger.info("No default job call file found at: %s", default_job_path)
            return ""

    except Exception as e:
        logger.warning("Failed to load default job call: %s", str(e))
        return ""


def summarize_job_call(job_call: str) -> str:
    '''Extracts and summarizes key information from job call.
    
    Args:
        job_call (str): Job call text to summarize. Must be provided and non-empty.
    
    Returns:
        str: Summarized job call information, or None if summarization fails
    '''

    if not job_call or not job_call.strip():
        logger.warning("No job call text provided for summarization")
        return None

    logger.info("Summarizing job call (%d characters)", len(job_call))

    client = OpenAI(api_key=os.environ['MODAL_API_KEY'])

    client.base_url = (
        'https://gperdrizet--vllm-openai-compatible-summarization-serve.modal.run/v1'
    )

    # Default to first available model
    model = client.models.list().data[0]
    model_id = model.id

    messages = [
        {
            'role': 'system',
            'content': f'{JOB_CALL_EXTRACTION_PROMPT}{job_call}'
        }
    ]

    completion_args = {
        'model': model_id,
        'messages': messages,
        # "frequency_penalty": args.frequency_penalty,
        # "max_tokens": 128,
        # "n": args.n,
        # "presence_penalty": args.presence_penalty,
        # "seed": args.seed,
        # "stop": args.stop,
        # "stream": args.stream,
        # "temperature": args.temperature,
        # "top_p": args.top_p,
    }

    try:
        response = client.chat.completions.create(**completion_args)

    except Exception as e:
        response = None
        logger.error('Error during Modal API call: %s', e)

    if response is not None:
        summary = response.choices[0].message.content

        # Save the extracted job call information to data directory
        try:
            _save_job_call_data(job_call, summary)
        except Exception as save_error:
            logger.warning("Failed to save job call data: %s", str(save_error))

    else:
        summary = None

    return summary


def _save_job_call_data(original_job_call: str, extracted_summary: str) -> None:
    """
    Save job call data (original and extracted summary) to the data/job_calls directory.

    Args:
        original_job_call (str): The original job call text
        extracted_summary (str): The extracted/summarized job call information
    """
    try:
        # Get the project root directory and job_calls subdirectory
        project_root = Path(__file__).parent.parent
        job_calls_dir = project_root / "data" / "job_calls"

        # Create job_calls directory if it doesn't exist
        job_calls_dir.mkdir(parents=True, exist_ok=True)

        # Create timestamped filename
        timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
        filename = f"job_call_extracted_{timestamp}.json"
        file_path = job_calls_dir / filename

        # Prepare data to save
        job_call_data = {
            "timestamp": datetime.now().isoformat(),
            "original_job_call": original_job_call,
            "extracted_summary": extracted_summary,
            "metadata": {
                "original_length": len(original_job_call),
                "summary_length": len(extracted_summary) if extracted_summary else 0,
                "extraction_successful": extracted_summary is not None
            }
        }

        # Save to JSON file
        with open(file_path, 'w', encoding='utf-8') as f:
            json.dump(job_call_data, f, indent=2, ensure_ascii=False)

        logger.info("Saved job call data to: %s", file_path)

    except Exception as e:
        logger.error("Error saving job call data: %s", str(e))
        raise