From b7c7f2b3ea36f172772c04e2ef023101bd8e7919 Mon Sep 17 00:00:00 2001 From: Russell Ballestrini Date: Thu, 20 Mar 2025 03:43:45 +0000 Subject: [PATCH] Update slop_with_models.py --- slop_with_models.py | 151 +++++++++++++++++++++++++++----------------- 1 file changed, 94 insertions(+), 57 deletions(-) diff --git a/slop_with_models.py b/slop_with_models.py index d292101..0d1e5c1 100644 --- a/slop_with_models.py +++ b/slop_with_models.py @@ -1,4 +1,3 @@ -# slop_with_models.py from flask import Flask, request, jsonify from datetime import datetime import os @@ -8,15 +7,19 @@ from flask_swagger_ui import get_swaggerui_blueprint # Configure logging logging.basicConfig( - level=logging.DEBUG, format="%(asctime)s - %(levelname)s - %(message)s" + level=logging.DEBUG, + handlers=[ + logging.FileHandler("slop_with_models.log"), # Log to a file + logging.StreamHandler(), # Also log to console + ] ) logger = logging.getLogger(__name__) app = Flask(__name__) # Swagger UI setup -SWAGGER_URL = "/openapi" # URL for Swagger UI -API_URL = "/static/openapi.yaml" # Path to the OpenAPI spec file +SWAGGER_URL = "/openapi" +API_URL = "/static/openapi.yaml" swaggerui_blueprint = get_swaggerui_blueprint( SWAGGER_URL, API_URL, config={"app_name": "SLOP API"} ) @@ -31,50 +34,49 @@ ENDPOINTS = [] for i in range(1000): endpoint = os.getenv(f"MODEL_ENDPOINT_{i}") if endpoint: + api_key = os.getenv(f"MODEL_API_KEY_{i}", "not-needed") + logger.info(f"Loaded endpoint {i}: {endpoint} with API key: {api_key[:4]}...") ENDPOINTS.append( { "name": f"endpoint_{i}", "base_url": endpoint, - "api_key": os.getenv(f"MODEL_API_KEY_{i}", "not-needed"), + "api_key": api_key, } ) - + else: + logger.debug(f"No endpoint found for MODEL_ENDPOINT_{i}") def initialize_model_map(): + logger.info("Starting model map initialization") MODEL_CLIENT_MAP.clear() - logger.info("Initializing model map...") if not ENDPOINTS: - logger.warning("No endpoints configured.") + logger.warning("No endpoints configured to initialize models") return for ep in ENDPOINTS: base_url = ep["base_url"] api_key = ep["api_key"] endpoint_name = ep["name"] - logger.info(f"Querying endpoint: {endpoint_name} ({base_url})") + logger.info(f"Initializing client for {endpoint_name} at {base_url}") client = OpenAI(base_url=base_url, api_key=api_key) try: + logger.debug(f"Attempting to list models from {endpoint_name}") response = client.models.list() model_list = response.data - logger.debug( - f"{endpoint_name} returned models: {[m.id for m in model_list]}" - ) + logger.debug(f"Models retrieved from {endpoint_name}: {[m.id for m in model_list]}") except Exception as e: - logger.error( - f"Skipping, Failed to list models for {endpoint_name}: {str(e)}" - ) + logger.error(f"Failed to list models for {endpoint_name}: {str(e)}", exc_info=True) continue for m in model_list: model_id = m.id if model_id: if model_id in MODEL_CLIENT_MAP: - logger.warning(f"Duplicate model ID '{model_id}' found.") + logger.warning(f"Duplicate model ID '{model_id}' found at {endpoint_name}") else: MODEL_CLIENT_MAP[model_id] = client - logger.info(f"Added model '{model_id}'") + logger.info(f"Registered model '{model_id}' from {endpoint_name}") else: - logger.warning(f"Encountered model with no ID from {endpoint_name}") - logger.info(f"Loaded models: {list(MODEL_CLIENT_MAP.keys())}") - + logger.warning(f"Model with no ID encountered from {endpoint_name}") + logger.info(f"Model map initialized with models: {list(MODEL_CLIENT_MAP.keys())}") # SLOP components tools = { @@ -91,20 +93,23 @@ tools = { } resources = {"hello": {"id": "hello", "content": "Hello, SLOP!"}} - # Endpoints @app.route("/chat", methods=["POST"]) def chat(): + logger.info("Received /chat request") data = request.json + logger.debug(f"Request data: {data}") message = data["messages"][0]["content"] if data.get("messages") else "nothing" model_id = data.get("model") or ( list(MODEL_CLIENT_MAP.keys())[0] if MODEL_CLIENT_MAP else None ) + logger.info(f"Selected model: {model_id}, message: {message}") if not model_id or model_id not in MODEL_CLIENT_MAP: - logger.error(f"Invalid or missing model_id: {model_id}") + logger.error(f"Invalid or missing model_id: {model_id}, available models: {list(MODEL_CLIENT_MAP.keys())}") return jsonify({"error": "Model not found"}), 404 client = MODEL_CLIENT_MAP[model_id] try: + logger.debug(f"Sending chat request to model {model_id}") response = client.chat.completions.create( model=model_id, messages=[ @@ -113,110 +118,142 @@ def chat(): ] or [{"role": "user", "content": message}], ) - logger.debug( - f"Chat response for model {model_id}: {response.choices[0].message.content}" - ) + response_content = response.choices[0].message.content + logger.debug(f"Chat response from {model_id}: {response_content}") return ( jsonify( { "choices": [ - {"message": {"content": response.choices[0].message.content}} + {"message": {"content": response_content}} ] } ), 200, ) except Exception as e: - logger.error(f"Chat error with model {model_id}: {str(e)}") + logger.error(f"Chat error with model {model_id}: {str(e)}", exc_info=True) return jsonify({"error": str(e)}), 500 - @app.route("/models", methods=["GET"]) def list_models(): + logger.info("Received /models request") models = list(MODEL_CLIENT_MAP.keys()) logger.debug(f"Returning models: {models}") return jsonify({"models": models}), 200 - @app.route("/tools", methods=["GET"]) def list_tools(): - return ( - jsonify( - { - "tools": [ - {"id": k, "description": v["description"]} for k, v in tools.items() - ] - } - ), - 200, - ) - + logger.info("Received /tools request") + tool_list = [{"id": k, "description": v["description"]} for k, v in tools.items()] + logger.debug(f"Returning tools: {tool_list}") + return jsonify({"tools": tool_list}), 200 @app.route("/tools/", methods=["POST"]) def use_tool(tool_id): + logger.info(f"Received /tools/{tool_id} request") if tool_id not in tools: + logger.error(f"Tool not found: {tool_id}") return jsonify({"error": "Tool not found"}), 404 data = request.json or {} + logger.debug(f"Tool {tool_id} input data: {data}") if tool_id == "calculator" and "expression" not in data: + logger.warning("Missing 'expression' for calculator tool") return jsonify({"error": "Missing 'expression'"}), 400 if tool_id == "greet" and "name" not in data: + logger.warning("Missing 'name' for greet tool") return jsonify({"error": "Missing 'name'"}), 400 - result = tools[tool_id]["execute"](data) - return jsonify(result), 200 - + try: + result = tools[tool_id]["execute"](data) + logger.debug(f"Tool {tool_id} result: {result}") + return jsonify(result), 200 + except Exception as e: + logger.error(f"Error executing tool {tool_id}: {str(e)}", exc_info=True) + return jsonify({"error": str(e)}), 500 @app.route("/memory", methods=["POST"]) def store_memory(): + logger.info("Received /memory POST request") data = request.json - memory[data["key"]] = data["value"] + logger.debug(f"Store memory data: {data}") + if not data or "key" not in data or "value" not in data: + logger.warning(f"Invalid memory store request: {data}") + return jsonify({"error": "Missing 'key' or 'value'"}), 400 + key, value = data["key"], data["value"] + memory[key] = value + logger.info(f"Stored in memory: {key} = {value}") + logger.debug(f"Current memory state: {memory}") return jsonify({"status": "stored"}), 200 - @app.route("/memory/", methods=["GET"]) def get_memory(key): - return jsonify({"value": memory.get(key)}), 200 - + logger.info(f"Received /memory/{key} GET request") + value = memory.get(key) + logger.debug(f"Retrieved memory for {key}: {value}") + if value is None: + logger.warning(f"Key not found in memory: {key}") + return jsonify({"value": value}), 200 @app.route("/memory", methods=["GET"]) def list_memory(): - return jsonify({"keys": list(memory.keys())}), 200 - + logger.info("Received /memory GET request") + keys = list(memory.keys()) + logger.debug(f"Memory keys: {keys}") + logger.debug(f"Full memory state: {memory}") + return jsonify({"keys": keys}), 200 @app.route("/memory/", methods=["DELETE"]) def delete_memory(key): + logger.info(f"Received /memory/{key} DELETE request") if key not in memory: + logger.warning(f"Key not found for deletion: {key}") return jsonify({"error": "Key not found"}), 404 + old_value = memory[key] del memory[key] + logger.info(f"Deleted from memory: {key} (was {old_value})") + logger.debug(f"Updated memory state: {memory}") return jsonify({"status": "deleted"}), 200 - @app.route("/resources", methods=["GET"]) def list_resources(): - return jsonify({"resources": list(resources.values())}), 200 - + logger.info("Received /resources request") + resource_list = list(resources.values()) + logger.debug(f"Returning resources: {resource_list}") + return jsonify({"resources": resource_list}), 200 @app.route("/resources/", methods=["GET"]) def get_resource(resource_id): + logger.info(f"Received /resources/{resource_id} request") if resource_id not in resources: + logger.error(f"Resource not found: {resource_id}") return jsonify({"error": "Resource not found"}), 404 - return jsonify(resources[resource_id]), 200 - + resource = resources[resource_id] + logger.debug(f"Returning resource {resource_id}: {resource}") + return jsonify(resource), 200 @app.route("/pay", methods=["POST"]) def pay(): + logger.info("Received /pay request") + data = request.json + logger.debug(f"Pay request data: {data}") + amount = data.get("amount", 0) + transaction_id = f"tx_{int(datetime.now().timestamp())}" + logger.info(f"Processed payment of {amount} with transaction ID: {transaction_id}") return ( jsonify( { - "transaction_id": f"tx_{int(datetime.now().timestamp())}", + "transaction_id": transaction_id, "status": "success", } ), 200, ) - +# Initialize model map on startup +logger.info("Starting application initialization") initialize_model_map() - +logger.info("Application initialization completed") if __name__ == "__main__": + logger.info("Starting Flask application on port 31337") app.run(debug=True, port=31337) + logger.info("Flask application stopped") \ No newline at end of file