Delete pubchemlite_invitrodb_to_dify_en.py

pubchemlite_invitrodb_to_dify_en.py

@@ -1,151 +0,0 @@
-# Import dependency libraries
-from flask import Flask, request, jsonify
-import pandas as pd
-import sqlalchemy
-from sqlalchemy.exc import SQLAlchemyError
-
-# Create Flask application
-app = Flask(__name__)
-
-# Configure connection information for two databases (please modify username/password/address according to actual environment)
-DB_CONFIGS = {
-    "pubchemlite": {
-        "uri": "mysql+pymysql://root:mysql1086@localhost:3306/pubchemlite"
-    },
-    "invitrodb_v4_3": {
-        "uri": "mysql+pymysql://root:mysql1086@localhost:3306/invitrodb_v4_3"  # Please confirm database name and password
-    }
-}
-
-# List of allowed database identifiers
-ALLOWED_DB_IDENTIFIERS = list(DB_CONFIGS.keys())
-# Only allow SELECT operations (security restriction)
-ALLOWED_SQL_OPERATIONS = ["select"]
-
-
-# Core interface: /execute_sql (supports POST method, GET only returns description)
-@app.route('/execute_sql', methods=['GET', 'POST'])
-def execute_sql():
-    # GET request returns interface description
-    if request.method == 'GET':
-        return jsonify({
-            "status": "info",
-            "message": "Please use POST method to call, parameters include db_identifier (pubchemlite/invitrodb_v4_3) and sql (SELECT only)"
-        })
-
-    try:
-        # 1. Get and validate request parameters
-        data = request.json
-        if not data:
-            return jsonify({
-                "status": "error",
-                "message": "Request body cannot be empty, must contain db_identifier and sql parameters"
-            }), 400
-
-        # Get database identifier and validate
-        db_identifier = data.get("db_identifier")
-        if not db_identifier:
-            return jsonify({
-                "status": "error",
-                "message": "Missing required parameter: db_identifier (optional values: pubchemlite/invitrodb_v4_3)"
-            }), 400
-
-        if db_identifier not in ALLOWED_DB_IDENTIFIERS:
-            return jsonify({
-                "status": "error",
-                "message": f"Invalid db_identifier: {db_identifier}, only supports: {','.join(ALLOWED_DB_IDENTIFIERS)}"
-            }), 400
-
-        # Get SQL and validate
-        sql = data.get("sql")
-        if not sql:
-            return jsonify({
-                "status": "error",
-                "message": "Missing required parameter: sql (SELECT query statements only)"
-            }), 400
-
-        # Security check: only allow SELECT operations
-        sql_lower = sql.strip().lower()
-        if not sql_lower.startswith(tuple(ALLOWED_SQL_OPERATIONS)):
-            return jsonify({
-                "status": "error",
-                "message": "Only SELECT query operations are supported, dangerous operations like INSERT/UPDATE/DELETE/DROP are prohibited"
-            }), 400
-
-        # 2. Create connection engine for the corresponding database
-        db_uri = DB_CONFIGS[db_identifier]["uri"]
-        engine = sqlalchemy.create_engine(
-            db_uri,
-            pool_pre_ping=True,  # Check connection validity
-            pool_recycle=3600  # Recycle connections every 1 hour to prevent timeouts
-        )
-
-        # 3. Execute SQL query
-        with engine.connect() as conn:
-            df = pd.read_sql(sql, conn)
-
-        # 4. Return successful result
-        return jsonify({
-            "status": "success",
-            "data": df.to_dict(orient="records"),
-            "message": ""
-        })
-
-    # Database execution error (table/field does not exist, etc.)
-    except SQLAlchemyError as e:
-        error_msg = str(e)
-        # Refine error messages to fit the two database scenarios
-        if "pubchemlite_ccs" in error_msg and db_identifier == "invitrodb_v4_3":
-            error_msg = f"pubchemlite_ccs table does not exist in invitrodb_v4_3 database (this table is only supported in pubchemlite): {error_msg}"
-        elif "CompoundName" in error_msg and db_identifier == "invitrodb_v4_3":
-            error_msg = f"CompoundName field does not exist in invitrodb_v4_3 database (this field is only supported in pubchemlite_ccs table of pubchemlite): {error_msg}"
-        elif "assay" in error_msg and db_identifier == "pubchemlite":
-            error_msg = f"assay table does not exist in pubchemlite database (this table is only supported in invitrodb_v4_3): {error_msg}"
-        return jsonify({
-            "status": "error",
-            "message": f"Database execution error: {error_msg}"
-        }), 500
-
-    # Client issues such as parameter/format errors
-    except Exception as e:
-        return jsonify({
-            "status": "error",
-            "message": f"Request processing failed: {str(e)}"
-        }), 400
-
-
-# Root directory route (provides interface usage instructions)
-@app.route('/')
-def home():
-    return """
-<h1>SQL Execution API (Supports Dual Databases)</h1> 
-<p>Please send POST requests to <code>/execute_sql</code> to execute SQL queries.</p>
-<p>Request parameters:</p>
-<ul>
-  <li>db_identifier: Target database (required, optional values: pubchemlite/invitrodb_v4_3)</li>
-  <li>sql: SELECT query statement (required, SELECT operations only)</li>
-</ul>
-<p>Example 1 (query pubchemlite):</p>
-<pre>
-curl -X POST http://127.0.0.1:5000/execute_sql \\
--H "Content-Type: application/json" \\
--d '{
-  "db_identifier": "pubchemlite",
-  "sql": "SELECT Identifier, CompoundName, MolecularFormula FROM pubchemlite_ccs WHERE PubMed_Count > 5 LIMIT 10"
-}'
-</pre>
-<p>Example 2 (query invitrodb_v4_3):</p>
-<pre>
-curl -X POST http://127.0.0.1:5000/execute_sql \\
--H "Content-Type: application/json" \\
--d '{
-  "db_identifier": "invitrodb_v4_3",
-  "sql": "SELECT aid, assay_name, organism FROM assay WHERE ncbi_taxon_id = 9606 LIMIT 10"
-}'
-</pre>
-"""
-
-
-# Start the application (listen on all network interfaces, port 5000, debug mode can be turned off)
-if __name__ == '__main__':
-    app.run(host='0.0.0.0', port=5000, debug=False)