#!/usr/bin/env python3
"""
Main entry point for [Function Name] functionality.
This script accepts command line arguments and executes the [function_name] function.
"""

import argparse
import logging
import sys

# Add the src directory to the Python path
sys.path.append("/app/src")

from extract_and_load import your_function

logging.basicConfig(
    level=logging.INFO,
    format="%(asctime)s - %(levelname)s - %(message)s",
    handlers=[logging.StreamHandler(sys.stdout)],
)

def main():
    """Main function to parse arguments and execute [Function Name]."""
    
    parser = argparse.ArgumentParser(
        description="[Description of what the function does]",
        formatter_class=argparse.RawDescriptionHelpFormatter,
        epilog="""
Examples:
  python main.py --param1 value1 --param2 value2
        """,
    )

    # Add your arguments here
    parser.add_argument("--param1", required=True, help="Description of param1")
    parser.add_argument("--param2", required=True, help="Description of param2")

    args = parser.parse_args()

    # Log the operation details
    logging.info("Starting [Function Name] operation")
    logging.info(f"Param1: {args.param1}")
    logging.info(f"Param2: {args.param2}")

    try:
        # Execute the function
        success, error_message = your_function(
            param1=args.param1,
            param2=args.param2,
        )

        if success:
            logging.info("✅ Operation completed successfully!")
            sys.exit(0)
        else:
            logging.error(f"❌ Operation failed: {error_message}")
            sys.exit(1)

    except Exception as e:
        logging.error(f"❌ Unexpected error: {str(e)}")
        sys.exit(1)

if __name__ == "__main__":
    main()

import json
import logging
import os
import sys

# Add the src directory to the Python path
if os.path.exists("/var/task/src"):
    # Running in Lambda
    sys.path.append("/var/task/src")
else:
    # Running locally
    sys.path.append("../../src")

from extract_and_load import your_function

# Configure logging for Lambda
logger = logging.getLogger()
logger.setLevel(logging.INFO)

def lambda_handler(event, context):
    """
    AWS Lambda handler for [Function Name] functionality.

    Expected event structure:
    {
        "param1": "value1",
        "param2": "value2"
    }

    Returns:
    {
        "statusCode": 200 or 500,
        "body": JSON string with success message or error details
    }
    """

    try:
        # Extract parameters from the event
        param1 = event.get("param1")
        param2 = event.get("param2")

        # Validate required parameters
        required_params = {
            "param1": param1,
            "param2": param2,
        }

        missing_params = [
            param for param, value in required_params.items() if not value
        ]

        if missing_params:
            error_msg = f"Missing required parameters: {', '.join(missing_params)}"
            logger.error(error_msg)

            return {
                "statusCode": 400,
                "body": json.dumps({
                    "success": False,
                    "error": error_msg,
                    "required_parameters": list(required_params.keys()),
                }),
            }

        # Log the operation details
        logger.info("Starting [Function Name] operation")
        logger.info(f"Param1: {param1}")
        logger.info(f"Param2: {param2}")

        # Execute the function
        success, error_message = your_function(
            param1=param1,
            param2=param2,
        )

        if success:
            logger.info("✅ Operation completed successfully!")

            return {
                "statusCode": 200,
                "body": json.dumps({
                    "success": True,
                    "message": "Operation completed successfully",
                    "param1": param1,
                    "param2": param2,
                }),
            }
        else:
            logger.error(f"❌ Operation failed: {error_message}")

            return {
                "statusCode": 500,
                "body": json.dumps({
                    "success": False,
                    "error": error_message,
                    "param1": param1,
                    "param2": param2,
                }),
            }

    except Exception as e:
        error_msg = f"[Function Name] failed: {str(e)}"
        logger.error(error_msg, exc_info=True)

        return {
            "statusCode": 500,
            "body": json.dumps({
                "success": False,
                "error": error_msg,
                "param1": param1 if "param1" in locals() else None,
                "param2": param2 if "param2" in locals() else None,
            }),
        }