app.py

import streamlit as st
import requests
import json
import re
import logging
from typing import Dict, Any, Optional

# Setup logging
logging.basicConfig(level=logging.INFO)

# API Configuration
GROQ_API_URL = "https://api.groq.com/openai/v1/chat/completions"
GROQ_API_KEY = "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"
GROQ_HEADERS = {
    "Authorization": f"Bearer {GROQ_API_KEY}",
    "Content-Type": "application/json",
}

# Shopify Configuration
STORE_NAME = "agkd0n-fa"  # Your store name
API_VERSION = "2024-04"    # Current API version
SHOPIFY_URL = f"https://{STORE_NAME}.myshopify.com/admin/api/{API_VERSION}/graphql.json"
SHOPIFY_ACCESS_TOKEN = "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"
SHOPIFY_HEADERS = {
    "Content-Type": "application/json",
    "X-Shopify-Access-Token": SHOPIFY_ACCESS_TOKEN,
}

def fetch_graphql_schema() -> Dict[str, Any]:
    """Fetch the GraphQL schema from Shopify."""
    introspection_query = """
    {
      "__schema" {
        "types" {
          "name"
        }
      }
    }
    """
    try:
        response = requests.post(
            SHOPIFY_URL,
            headers=SHOPIFY_HEADERS,
            json={"query": introspection_query}
        )
        response.raise_for_status()
        return response.json()
    except Exception as e:
        logging.error(f"Error fetching schema: {str(e)}")
        return {"error": str(e)}


def convert_to_graphql_query(natural_language: str) -> str:
    """Convert natural language to a GraphQL query using the Groq API."""
    # Enhanced prompt with Shopify Admin API specific guidance
    prompt = f"""
    Create a Shopify Admin API GraphQL query for this request: "{natural_language}"
    
    Follow these Shopify Admin API rules:
    1. For text searches in product queries:
       - Use the query parameter with these prefixes:
         * title: for product titles
         * description: for product descriptions
         * tag: for product tags
         * product_type: for product types
       - Example: query: "title:shirt OR description:cotton"
       
    2. For price filters:
       - Use variants.price for exact price
       - Use variants.price:<number for maximum price
       - Use variants.price:>number for minimum price
       - Example: query: "variants.price:<50.00"
       
    3. Include these fields in the response:
       - id
       - title
       - description
       - productType
       - priceRangeV2 with minVariantPrice (amount and currencyCode)
       - images (first: 1) with url
       
    4. Use proper pagination with first: 250
    
    Return only the complete GraphQL query, no explanations.
    """
    
    payload = {
        "model": "llama3-8b-8192",
        "messages": [{"role": "user", "content": prompt}],
        "temperature": 0.1,
        "max_tokens": 500,
    }

    try:
        response = requests.post(GROQ_API_URL, headers=GROQ_HEADERS, json=payload)
        response.raise_for_status()
        
        query = response.json()['choices'][0]['message']['content'].strip()
        return clean_query(query)
    except Exception as e:
        logging.error(f"Query generation error: {str(e)}")
        return get_default_query()

def clean_query(query: str) -> str:
    """Clean and format the GraphQL query."""
    # Remove code block markers and quotes
    query = re.sub(r'```(?:graphql)?\s*|\s*```|^["\']\s*|\s*["\']$', '', query)
    
    # Extract the query content
    query_match = re.search(r'({[\s\S]*})', query)
    if not query_match:
        return get_default_query()
    
    query = query_match.group(1)
    
    # Ensure the query has all required fields
    if not all(field in query for field in ['id', 'title', 'description', 'productType', 'priceRangeV2', 'images']):
        return get_default_query()
        
    # Format the query
    try:
        formatted_query = format_query(query)
        return formatted_query
    except Exception as e:
        logging.error(f"Query formatting error: {str(e)}")
        return get_default_query()

def format_query(query: str) -> str:
    """Format the GraphQL query with proper indentation."""
    depth = 0
    formatted = []
    lines = query.split('\n')
    
    for line in lines:
        line = line.strip()
        
        # Adjust depth based on brackets
        if '}' in line:
            depth -= 1
        
        # Add indentation
        if line:
            formatted.append('  ' * depth + line)
            
        # Increase depth for next line if needed
        if '{' in line:
            depth += 1
            
    return '\n'.join(formatted)

def get_default_query() -> str:
    """Return a default working query with all required fields."""
    return """
{
  products(first: 250) {
    edges {
      node {
        id
        title
        description
        productType
        priceRangeV2 {
          minVariantPrice {
            amount
            currencyCode
          }
        }
        images(first: 1) {
          edges {
            node {
              url
            }
          }
        }
      }
    }
  }
}
""".strip()

def execute_query(query: str) -> Dict[str, Any]:
    """Execute a GraphQL query against the Shopify Admin API."""
    try:
        response = requests.post(
            SHOPIFY_URL,
            headers=SHOPIFY_HEADERS,
            json={"query": query}
        )
        response.raise_for_status()
        return response.json()
    except Exception as e:
        logging.error(f"Query execution error: {str(e)}")
        return {"error": str(e)}

def format_response(response: Dict[str, Any]) -> Dict[str, Any]:
    """Format the API response for display."""
    if "errors" in response:
        error_message = response["errors"][0]["message"]
        logging.error(f"Shopify API returned an error: {error_message}")
        return {"error": error_message}
    
    try:
        products_data = response.get("data", {}).get("products", {}).get("edges", [])
        if not products_data:
            return {"error": "No products found in response"}
            
        formatted = {"products": []}
        for edge in products_data:
            node = edge.get("node", {})
            product = {
                "title": node.get("title", ""),
                "description": node.get("description", ""),
                "productType": node.get("productType", ""),
                "price": None,
                "image": None
            }
            price_range = node.get("priceRangeV2", {}).get("minVariantPrice", {})
            if price_range:
                amount = price_range.get("amount")
                currency = price_range.get("currencyCode")
                if amount and currency:
                    product["price"] = f"{float(amount):.2f} {currency}"
            
            images = node.get("images", {}).get("edges", [])
            if images:
                product["image"] = images[0].get("node", {}).get("url")
            
            formatted["products"].append(product)
        
        return formatted
    except Exception as e:
        logging.error(f"Response formatting error: {str(e)}")
        return {"error": str(e)}

def main():
    st.title("Shopify Product Search")
    
    # Fetch schema for dynamic query generation
    schema = fetch_graphql_schema()
    
    if "error" in schema:
        st.error(f"Failed to fetch schema: {schema['error']}")
        return
    
    # Display the available types or fields for user to choose from
    types = schema.get("data", {}).get("__schema", {}).get("types", [])
    st.subheader("Available Types in Shopify GraphQL Schema:")
    for type_info in types:
        st.write(type_info["name"])

    st.markdown("""
    ### Example Queries:
    - Show all products
    - Find products under $50
    - Search for products with "cotton" in description
    - Find products tagged as "summer"
    - Search for specific product types
    """)
    
    query = st.text_input(
        "What products are you looking for?",
        placeholder="e.g., Find t-shirts under $50"
    )

    if query and st.button("Search"):
        try:
            with st.spinner("Generating query..."):
                graphql_query = convert_to_graphql_query(query)
                
                with st.expander("View GraphQL Query"):
                    st.code(graphql_query, language='graphql')
                
            with st.spinner("Searching products..."):
                response = execute_query(graphql_query)
                
                if "errors" in response:
                    st.error("Query Error")
                    st.json(response["errors"])
                    return
                
                formatted = format_response(response)
                
                if "error" in formatted:
                    st.error(formatted["error"])
                    return
                
                if formatted["products"]:
                    st.subheader(f"Found {len(formatted['products'])} products")
                    for product in formatted["products"]:
                        with st.container():
                            cols = st.columns([1, 2])
                            with cols[0]:
                                if product["image"]:
                                    st.image(product["image"])
                            with cols[1]:
                                st.markdown(f"**{product['title']}**")
                                st.write(f"Type: {product['productType']}")
                                if product["price"]:
                                    st.write(f"Price: {product['price']}")
                                st.write(product["description"])
                            st.divider()
                else:
                    st.warning("No products found.")
                    
        except Exception as e:
            st.error(f"An error occurred: {str(e)}")
            logging.exception("Main execution error")