sacrificialpancakes/slop.unturf.com
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Update slop_with_models.py

Browse source
This commit is contained in:
Russell Ballestrini 2025-03-20 03:43:45 +00:00
parent b2a7f9838d
commit b7c7f2b3ea
1 changed files with 94 additions and 57 deletions
Download patch file Download diff file Expand all files Collapse all files

151
slop_with_models.py
View file

@ -1,4 +1,3 @@
# slop_with_models.py
from flask import Flask, request, jsonify from flask import Flask, request, jsonify
from datetime import datetime from datetime import datetime
import os import os
@ -8,15 +7,19 @@ from flask_swagger_ui import get_swaggerui_blueprint
# Configure logging # Configure logging
logging.basicConfig( 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__) logger = logging.getLogger(__name__)
app = Flask(__name__) app = Flask(__name__)
# Swagger UI setup # Swagger UI setup
SWAGGER_URL = "/openapi" # URL for Swagger UI SWAGGER_URL = "/openapi"
API_URL = "/static/openapi.yaml" # Path to the OpenAPI spec file API_URL = "/static/openapi.yaml"
swaggerui_blueprint = get_swaggerui_blueprint( swaggerui_blueprint = get_swaggerui_blueprint(
SWAGGER_URL, API_URL, config={"app_name": "SLOP API"} SWAGGER_URL, API_URL, config={"app_name": "SLOP API"}
) )
@ -31,50 +34,49 @@ ENDPOINTS = []
for i in range(1000): for i in range(1000):
endpoint = os.getenv(f"MODEL_ENDPOINT_{i}") endpoint = os.getenv(f"MODEL_ENDPOINT_{i}")
if endpoint: 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( ENDPOINTS.append(
{ {
"name": f"endpoint_{i}", "name": f"endpoint_{i}",
"base_url": endpoint, "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(): def initialize_model_map():
logger.info("Starting model map initialization")
MODEL_CLIENT_MAP.clear() MODEL_CLIENT_MAP.clear()
logger.info("Initializing model map...")
if not ENDPOINTS: if not ENDPOINTS:
logger.warning("No endpoints configured.") logger.warning("No endpoints configured to initialize models")
return return
for ep in ENDPOINTS: for ep in ENDPOINTS:
base_url = ep["base_url"] base_url = ep["base_url"]
api_key = ep["api_key"] api_key = ep["api_key"]
endpoint_name = ep["name"] 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) client = OpenAI(base_url=base_url, api_key=api_key)
try: try:
logger.debug(f"Attempting to list models from {endpoint_name}")
response = client.models.list() response = client.models.list()
model_list = response.data model_list = response.data
logger.debug( logger.debug(f"Models retrieved from {endpoint_name}: {[m.id for m in model_list]}")
f"{endpoint_name} returned models: {[m.id for m in model_list]}"
)
except Exception as e: except Exception as e:
logger.error( logger.error(f"Failed to list models for {endpoint_name}: {str(e)}", exc_info=True)
f"Skipping, Failed to list models for {endpoint_name}: {str(e)}"
)
continue continue
for m in model_list: for m in model_list:
model_id = m.id model_id = m.id
if model_id: if model_id:
if model_id in MODEL_CLIENT_MAP: 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: else:
MODEL_CLIENT_MAP[model_id] = client MODEL_CLIENT_MAP[model_id] = client
logger.info(f"Added model '{model_id}'") logger.info(f"Registered model '{model_id}' from {endpoint_name}")
else: else:
logger.warning(f"Encountered model with no ID from {endpoint_name}") logger.warning(f"Model with no ID encountered from {endpoint_name}")
logger.info(f"Loaded models: {list(MODEL_CLIENT_MAP.keys())}") logger.info(f"Model map initialized with models: {list(MODEL_CLIENT_MAP.keys())}")
# SLOP components # SLOP components
tools = { tools = {
@ -91,20 +93,23 @@ tools = {
} }
resources = {"hello": {"id": "hello", "content": "Hello, SLOP!"}} resources = {"hello": {"id": "hello", "content": "Hello, SLOP!"}}
# Endpoints # Endpoints
@app.route("/chat", methods=["POST"]) @app.route("/chat", methods=["POST"])
def chat(): def chat():
logger.info("Received /chat request")
data = request.json data = request.json
logger.debug(f"Request data: {data}")
message = data["messages"][0]["content"] if data.get("messages") else "nothing" message = data["messages"][0]["content"] if data.get("messages") else "nothing"
model_id = data.get("model") or ( model_id = data.get("model") or (
list(MODEL_CLIENT_MAP.keys())[0] if MODEL_CLIENT_MAP else None 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: 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 return jsonify({"error": "Model not found"}), 404
client = MODEL_CLIENT_MAP[model_id] client = MODEL_CLIENT_MAP[model_id]
try: try:
logger.debug(f"Sending chat request to model {model_id}")
response = client.chat.completions.create( response = client.chat.completions.create(
model=model_id, model=model_id,
messages=[ messages=[
@ -113,110 +118,142 @@ def chat():
] ]
or [{"role": "user", "content": message}], or [{"role": "user", "content": message}],
) )
logger.debug( response_content = response.choices[0].message.content
f"Chat response for model {model_id}: {response.choices[0].message.content}" logger.debug(f"Chat response from {model_id}: {response_content}")
)
return ( return (
jsonify( jsonify(
{ {
"choices": [ "choices": [
{"message": {"content": response.choices[0].message.content}} {"message": {"content": response_content}}
] ]
} }
), ),
200, 200,
) )
except Exception as e: 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 return jsonify({"error": str(e)}), 500
@app.route("/models", methods=["GET"]) @app.route("/models", methods=["GET"])
def list_models(): def list_models():
logger.info("Received /models request")
models = list(MODEL_CLIENT_MAP.keys()) models = list(MODEL_CLIENT_MAP.keys())
logger.debug(f"Returning models: {models}") logger.debug(f"Returning models: {models}")
return jsonify({"models": models}), 200 return jsonify({"models": models}), 200
@app.route("/tools", methods=["GET"]) @app.route("/tools", methods=["GET"])
def list_tools(): def list_tools():
return ( logger.info("Received /tools request")
jsonify( tool_list = [{"id": k, "description": v["description"]} for k, v in tools.items()]
{ logger.debug(f"Returning tools: {tool_list}")
"tools": [ return jsonify({"tools": tool_list}), 200
{"id": k, "description": v["description"]} for k, v in tools.items()
]
}
),
200,
)
@app.route("/tools/<tool_id>", methods=["POST"]) @app.route("/tools/<tool_id>", methods=["POST"])
def use_tool(tool_id): def use_tool(tool_id):
logger.info(f"Received /tools/{tool_id} request")
if tool_id not in tools: if tool_id not in tools:
logger.error(f"Tool not found: {tool_id}")
return jsonify({"error": "Tool not found"}), 404 return jsonify({"error": "Tool not found"}), 404
data = request.json or {} data = request.json or {}
logger.debug(f"Tool {tool_id} input data: {data}")
if tool_id == "calculator" and "expression" not in data: if tool_id == "calculator" and "expression" not in data:
logger.warning("Missing 'expression' for calculator tool")
return jsonify({"error": "Missing 'expression'"}), 400 return jsonify({"error": "Missing 'expression'"}), 400
if tool_id == "greet" and "name" not in data: if tool_id == "greet" and "name" not in data:
logger.warning("Missing 'name' for greet tool")
return jsonify({"error": "Missing 'name'"}), 400 return jsonify({"error": "Missing 'name'"}), 400
result = tools[tool_id]["execute"](data) try:
return jsonify(result), 200 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"]) @app.route("/memory", methods=["POST"])
def store_memory(): def store_memory():
logger.info("Received /memory POST request")
data = request.json 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 return jsonify({"status": "stored"}), 200
@app.route("/memory/<key>", methods=["GET"]) @app.route("/memory/<key>", methods=["GET"])
def get_memory(key): 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"]) @app.route("/memory", methods=["GET"])
def list_memory(): 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/<key>", methods=["DELETE"]) @app.route("/memory/<key>", methods=["DELETE"])
def delete_memory(key): def delete_memory(key):
logger.info(f"Received /memory/{key} DELETE request")
if key not in memory: if key not in memory:
logger.warning(f"Key not found for deletion: {key}")
return jsonify({"error": "Key not found"}), 404 return jsonify({"error": "Key not found"}), 404
old_value = memory[key]
del 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 return jsonify({"status": "deleted"}), 200
@app.route("/resources", methods=["GET"]) @app.route("/resources", methods=["GET"])
def list_resources(): 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/<resource_id>", methods=["GET"]) @app.route("/resources/<resource_id>", methods=["GET"])
def get_resource(resource_id): def get_resource(resource_id):
logger.info(f"Received /resources/{resource_id} request")
if resource_id not in resources: if resource_id not in resources:
logger.error(f"Resource not found: {resource_id}")
return jsonify({"error": "Resource not found"}), 404 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"]) @app.route("/pay", methods=["POST"])
def pay(): 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 ( return (
jsonify( jsonify(
{ {
"transaction_id": f"tx_{int(datetime.now().timestamp())}", "transaction_id": transaction_id,
"status": "success", "status": "success",
} }
), ),
200, 200,
) )
# Initialize model map on startup
logger.info("Starting application initialization")
initialize_model_map() initialize_model_map()
logger.info("Application initialization completed")
if __name__ == "__main__": if __name__ == "__main__":
logger.info("Starting Flask application on port 31337")
app.run(debug=True, port=31337) app.run(debug=True, port=31337)
logger.info("Flask application stopped")