initial commit

app.py

@@ -0,0 +1,122 @@
+import streamlit as st
+import json
+import yaml
+import httpx
+from transformers import pipeline
+import logging
+
+# Initialize the Hugging Face model pipeline (using text generation model for simplicity)
+llm_model = pipeline('text-generation', model="bigscience/bloom-560m")
+
+# Configure logging
+logging.basicConfig(filename='api_client.log', level=logging.INFO, 
+                    format='%(asctime)s - %(levelname)s - %(message)s')
+
+
+def parse_api_spec(api_spec_content):
+    """
+    This function parses the uploaded API specification and returns endpoints and their parameters.
+    Assumes OpenAPI format.
+    """
+    try:
+        # Try to load as JSON first
+        api_spec = json.loads(api_spec_content)
+    except json.JSONDecodeError:
+        # If it's not JSON, try loading as YAML
+        api_spec = yaml.safe_load(api_spec_content)
+    
+    # Extract paths and methods
+    endpoints = {}
+    if 'paths' in api_spec:
+        for path, methods in api_spec['paths'].items():
+            for method, details in methods.items():
+                # Extract parameters
+                params = details.get('parameters', [])
+                param_info = {param['name']: param['in'] for param in params}
+                endpoints[f"{method.upper()} {path}"] = param_info
+    
+    return endpoints
+
+def generate_python_interface(endpoints):
+    """
+    Generates a Python interface based on the extracted API endpoints and parameters.
+    Includes logging of all API requests and responses.
+    """
+    interface_code = """
+import httpx
+import logging
+
+# Configure logging
+logging.basicConfig(filename='api_calls.log', level=logging.INFO, 
+                    format='%(asctime)s - %(levelname)s - %(message)s')
+
+class APIClient:
+    def __init__(self, base_url):
+        self.base_url = base_url
+        self.client = httpx.Client()
+
+    def call_api(self, method, endpoint, params=None, json=None):
+        url = f"{self.base_url}{endpoint}"
+        logging.info(f"Requesting {method} {url} with params: {params} and body: {json}")
+        
+        response = self.client.request(method, url, params=params, json=json)
+        
+        logging.info(f"Received response: {response.status_code} - {response.text}")
+        return response.json()
+
+# Example Usage:
+# api_client = APIClient(base_url="https://api.example.com")
+# response = api_client.call_api("GET", "/some-endpoint", {"param1": "value1"})
+    """
+    return interface_code
+
+def use_llm_to_extract(api_spec):
+    """
+    Uses a Hugging Face model to extract API details.
+    """
+    prompt = f"Extract API endpoints and parameters from the following API spec:\n{api_spec}"
+    response = llm_model(prompt, max_length=200, num_return_sequences=1)
+    
+    return response[0]['generated_text']
+
+def main():
+    st.title("API Spec Uploader and Python Interface Generator")
+
+    # Upload API Spec File
+    uploaded_file = st.file_uploader("Upload API Spec (JSON or YAML)", type=["json", "yaml"])
+
+    if uploaded_file is not None:
+        api_spec_content = uploaded_file.read().decode("utf-8")
+
+        # Display API Spec
+        st.subheader("Uploaded API Specification")
+        st.code(api_spec_content, language="json" if uploaded_file.type == "application/json" else "yaml")
+
+        # Extract API endpoints and parameters using LLM
+        with st.spinner('Extracting API information using Hugging Face LLM...'):
+            extracted_info = use_llm_to_extract(api_spec_content)
+            st.subheader("Extracted Information from LLM")
+            st.write(extracted_info)
+
+        # Parse the API spec manually to display extracted endpoints
+        endpoints = parse_api_spec(api_spec_content)
+        
+        if endpoints:
+            st.subheader("Parsed Endpoints and Parameters")
+            for endpoint, params in endpoints.items():
+                st.write(f"**{endpoint}**")
+                st.json(params)
+
+            # Generate Python interface code with logging
+            python_interface_code = generate_python_interface(endpoints)
+
+            st.subheader("Generated Python Interface with Logging")
+            st.code(python_interface_code, language="python")
+            
+            st.download_button(label="Download Python Interface",
+                               data=python_interface_code,
+                               file_name="api_interface.py",
+                               mime="text/plain")
+
+if __name__ == '__main__':
+    main()