Delete checks

checks/endpoint_check.py

@@ -1,85 +0,0 @@
-import requests
-import sys
-
-'''
-# Example usage:
-endpoint = "https://api-inference.huggingface.co/models/gpt2"
-status_info = check_endpoint(endpoint)
-
-if status_info["status"]:
-    print("Success:", status_info["message"])
-else:
-    print("Error:", status_info["message"])
-    print("Status Code:", status_info["status_code"])
-    print("Response Data:", status_info["response_data"])
-'''
-
-def check_public_endpoint(endpoint: str):
-    """
-    Checks the given endpoint and provides a detailed status and message.
-
-    Args:
-        endpoint (str): The URL of the endpoint to check.
-
-    Returns:
-        dict: Contains status (True/False) and a message explaining the result.
-    """
-    result = {
-        "status": False,  # Default status is failure
-        "message": "Unknown error",  # Default message
-        "status_code": None,
-        "response_data": None
-    }
-
-    try: # No Authorization header required for public models
-        response = requests.get(endpoint)
-        result["status_code"] = response.status_code
-        result["response_data"] = response.text
-
-        if response.status_code == 503:
-            result["status"] = True
-            result["message"] = "Endpoint is reachable and returned a service unavailable response."
-       
-        if response.status_code == 200:
-            result["status"] = True
-            result["message"] = "Endpoint is reachable and returned a valid response."
-        else:
-            result["message"] = f"Request failed with status code {response.status_code}. Response: {response.text}"
-
-    except requests.exceptions.RequestException as e:
-        result["message"] = f"Request failed with exception: {e}"
-
-    return result
-
-'''
-        # Check if the response status code is 200 and it returns inference data
-        if response.status_code == 200:
-            # Public models will return inference data without needing an API key
-            # Attempt to parse JSON response
-            response_json = response.json()
-            # Print the first few keys of the response JSON for debugging
-            print(f"Response JSON keys: {list(response_json.keys())[:5]}")
-
-            # Public models will return inference data without needing an API key
-            if "model" in response_json or "error" in response_json:
-                    return True
-            else:
-                print("The response does not contain inference-related data.")
-                return False
- 
-'''
-
-
-def is_huggingface_endpoint(endpoint: str):
-    try:
-        headers = {"Authorization": "Bearer YOUR_HUGGINGFACE_API_KEY"}
-        response = requests.get(endpoint, headers=headers)
-        
-        if response.status_code == 200 and "model" in response.json():
-            return True
-        else:
-            print("This is NOT a Hugging Face Inference Endpoint.")
-            return False
-    except requests.exceptions.RequestException as e:
-        print(f"Request failed: {e}")
-        return False

checks/failed_check.py

@@ -1,46 +0,0 @@
-import gradio as gr
-import time
-import random
-import os
-
-
-# Function to simulate the status of the app
-def check_app_status():
-    # Simulate different app statuses
-    status_options = [
-        "The app is building. Please wait a few moments...",
-        "The app is restarting. Hold on...",
-        "The endpoint is starting up. It might take a few minutes...",
-        "Payment is needed for inferences. Please complete payment to continue.",
-        "The endpoint is scaled to zero due to inactivity. Starting it now...",
-       
-    ]
-    
-    # Simulate a real condition check (for demonstration, we randomly select one status)
-    current_status = random.choice(status_options)
-    
-    # If the endpoint is scaled to zero, simulate the time it takes to start
-    if current_status == "The endpoint is scaled to zero due to inactivity. Starting it now...":
-        time.sleep(5)  # Simulate the time it takes to start the endpoint
-    
-    # Simulate some delay for other operations (like checking the status)
-    time.sleep(2)
-    return "App start up failure, please check back in a day or two"
-    return current_status
-
-
-# Function to simulate the button click event in Gradio UI
-def get_status():
-    return check_app_status()
-
-# Create the Gradio interface
-def create_failed_gradio_ui(status_info):
-    with gr.Blocks() as interface:
-        gr.Markdown(f"## Inference Endpoint Status")
-        gr.Markdown(f"### Status Code: {status_info['status_code']}")
-        gr.Markdown(f"### Message: {status_info['message']}")
-        gr.JSON(status_info["response_data"], label="Response Data")
-    return interface
-    
-
-

checks/health_check.py

@@ -1,53 +0,0 @@
-# checks/health_check.py
-import os
-import requests
-from typing import Dict, Tuple
-
-from checks.endpoint_check import check_public_endpoint
-
-def check_with_prompt(endpoint_uri: str):
-    
-    # Try a direct test of your endpoint
-    test_prompt = "Hello, how are you?"
-    response = requests.post(
-        endpoint_uri,
-        json={"inputs": test_prompt},
-        headers={"Authorization": f"Bearer {os.getenv('HF_TOKEN')}"}
-    )
-    print(response.json())
-
-
-
-def check_model_endpoint(endpoint_uri: str) -> Tuple[bool, Dict]:
-    """Comprehensive check of model endpoint health"""
-    # Basic availability check
-    status_info = check_public_endpoint(endpoint_uri)
-    
-    if not status_info["status"] or status_info["status_code"] in [503, 502]:
-        return False, status_info
-    
-    # Test actual model response
-    try:
-        test_prompt = "Hello, how are you?"
-        response = requests.post(
-            endpoint_uri,
-            json={"inputs": test_prompt},
-            headers={"Authorization": f"Bearer {os.getenv('HF_TOKEN')}"},
-            timeout=10
-        )
-        response.raise_for_status()
-        return True, {
-            "status": True,
-            "status_code": response.status_code,
-            "response": response.json()
-        }
-    except Exception as e:
-        return False, {
-            "status": False,
-            "status_code": 500,
-            "error": str(e)
-        }
-
-def should_launch_ui(status_info: Dict) -> bool:
-    """Determine if UI should be launched based on status"""
-    return status_info.get("status", False) and status_info.get("status_code", 500) == 200