# Example: Basic Flask API for a Python model endpoint
# This code sets up a simple web API for a hypothetical protein embedding model.
# Save this as `model_api.py`

from flask import Flask, request, jsonify
import numpy as np
# Assume 'your_model_package' contains your pre-trained protein language model
# and an inference function.
# Example: from your_model_package.model import ProteinEmbeddingModel, preprocess_sequence

app = Flask(__name__)

# Placeholder for your actual model loading and inference logic
# In a production environment, load your model ONCE when the API starts.
# model = ProteinEmbeddingModel.load('path/to/your/model.pth')

def get_protein_embedding(sequence: str):
    """Simulate model inference to get embeddings for a protein sequence."""
    if not isinstance(sequence, str) or not sequence:
        raise ValueError("Sequence must be a non-empty string.")
    # In reality:
    # processed_seq = preprocess_sequence(sequence)
    # embedding = model.predict(processed_seq)
    # For this example, we generate a dummy embedding.
    dummy_embedding = np.random.rand(128).tolist() # 128-dimensional embedding
    return dummy_embedding

@app.route('/predict_embedding', methods=['POST'])
def predict_embedding():
    """API endpoint to receive a protein sequence and return its embedding."""
    try:
        data = request.get_json()
        if not data or 'sequence' not in data:
            return jsonify({'error': 'Missing sequence in request body'}), 400
        
        sequence = data['sequence']
        embedding = get_protein_embedding(sequence)
        
        return jsonify({'sequence': sequence, 'embedding': embedding}), 200
    except ValueError as e:
        return jsonify({'error': str(e)}), 400
    except Exception as e:
        return jsonify({'error': f'Internal server error: {str(e)}'}), 500

# To run this API:
# 1. pip install Flask numpy
# 2. python model_api.py
# This will start the server, typically on http://127.0.0.1:5000/

# Example: Python client to interact with the deployed model API
# This script demonstrates how to send a sequence to the Flask API and receive embeddings.
# Save this as `pipeline_step_1.py`

import requests
import json
import os

# Configuration for the model API endpoint
MODEL_API_URL = os.getenv('MODEL_API_URL', 'http://127.0.0.1:5000/predict_embedding')

def get_embedding_from_api(sequence: str) -> dict:
    """Sends a protein sequence to the model API and retrieves its embedding."""
    headers = {'Content-Type': 'application/json'}
    payload = {'sequence': sequence}
    try:
        response = requests.post(MODEL_API_URL, headers=headers, json=payload, timeout=30)
        response.raise_for_status() # Raise an exception for HTTP errors (4xx or 5xx)
        return response.json()
    except requests.exceptions.HTTPError as errh:
        print(f"HTTP Error: {errh}")
        raise
    except requests.exceptions.ConnectionError as errc:
        print(f"Error Connecting: {errc}")
        raise
    except requests.exceptions.Timeout as errt:
        print(f"Timeout Error: {errt}")
        raise
    except requests.exceptions.RequestException as err:
        print(f"Something went wrong: {err}")
        raise

def main():
    # Example usage within a pipeline context
    protein_sequences = [
        "MVHLTPEEKSAVTALWGKVNVDEVGGEALGRLLVVYPWTQRFFESFGDLSTPDAVMGNPKVKAHGKKVLGAFSDGLAHLDNLKGTFATLSELHCDKLHVDPENFRLLGNVLVCVLAHHFGKEFTPPVQAAYQKVVAGVANALAHKYH",
        "GAILTVQSPGTLSVTTSPGETTVLTCGSSTGAVTSGYYPVSQKVF" # Another example sequence
    ]

    all_results = []
    for i, seq in enumerate(protein_sequences):
        print(f"Processing sequence {i+1}/{len(protein_sequences)}...")
        try:
            result = get_embedding_from_api(seq)
            all_results.append(result)
            print(f"Received embedding for sequence: {result['sequence'][:30]}...")
        except Exception as e:
            print(f"Failed to get embedding for sequence: {seq[:30]}... Error: {e}")
            # Implement robust error handling or retry logic here
            
    # Output results, perhaps to a file for downstream processing
    with open('protein_embeddings.json', 'w') as f:
        json.dump(all_results, f, indent=4)
    print("Embeddings saved to protein_embeddings.json")

if __name__ == "__main__":
    # Ensure the model_api.py is running before executing this script
    main()

# Example: Integrating a Python client script into a Snakemake workflow
# This `Snakefile` demonstrates a simple pipeline that uses our Python client.
# Ensure `pipeline_step_1.py` and `model_api.py` (running) are in the same directory
# or accessible via environment variables.

# Snakefile (save this as `Snakefile`)

# Define target output file
TARGET_EMBEDDINGS_FILE = "protein_embeddings.json"

rule all:
    input: TARGET_EMBEDDINGS_FILE

rule generate_embeddings:
    output:
        TARGET_EMBEDDINGS_FILE
    params:
        api_url = "http://127.0.0.1:5000/predict_embedding" # Or use os.getenv('MODEL_API_URL')
    shell:
        "export MODEL_API_URL={params.api_url} && python pipeline_step_1.py"

# To run this Snakemake pipeline:
# 1. Ensure `model_api.py` is running in a separate terminal.
#    (e.g., `python model_api.py`)
# 2. pip install snakemake
# 3. snakemake --cores 1
# This will execute `pipeline_step_1.py` and generate `protein_embeddings.json`.

# This example can be extended with more rules for upstream data preparation
# and downstream analysis, all orchestrated by Snakemake.
# For example, a rule to parse a FASTA file into sequences consumable by pipeline_step_1.py.
# rule parse_fasta:
#     input: "input.fasta"
#     output: "sequences.json"
#     shell: "python scripts/fasta_parser.py {input} > {output}"
# Then, `pipeline_step_1.py` would read from "sequences.json" instead of hardcoded list.

# Example: Basic logging for the Python model API (model_api.py) and client (pipeline_step_1.py)
# This demonstrates how to add basic logging for better monitoring and debugging.

# Modifications to `model_api.py` (add to the top of the file):
import logging

logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')

# Example of using logging within the predict_embedding function:
# @app.route('/predict_embedding', methods=['POST'])
# def predict_embedding():
#     try:
#         data = request.get_json()
#         logging.info(f"Received request for sequence: {data.get('sequence', 'N/A')[:20]}...")
#         ...
#     except ValueError as e:
#         logging.error(f"Validation error: {e}")
#         ...
#     except Exception as e:
#         logging.critical(f"Unhandled API error: {e}", exc_info=True) # exc_info to log traceback
#         ...

# Modifications to `pipeline_step_1.py` (add to the top of the file):
# import logging

# logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')

# Example of using logging within get_embedding_from_api and main:
# def get_embedding_from_api(sequence: str) -> dict:
#     ...
#     try:
#         response = requests.post(MODEL_API_URL, headers=headers, json=payload, timeout=30)
#         response.raise_for_status()
#         logging.info(f"Successfully retrieved embedding for sequence: {sequence[:20]}...")
#         return response.json()
#     except requests.exceptions.HTTPError as errh:
#         logging.error(f"HTTP Error during embedding retrieval: {errh}")
#         raise
#     ...

# def main():
#     ...
#     for i, seq in enumerate(protein_sequences):
#         logging.info(f"Starting processing for sequence {i+1}/{len(protein_sequences)}...")
#         try:
#             result = get_embedding_from_api(seq)
#             logging.debug(f"Full result for {seq[:20]}...: {result}") # Use debug for verbose output
#             ...
#         except Exception as e:
#             logging.exception(f"Failed to process sequence {seq[:20]}...") # Logs error with traceback
#             ...