Create app.py

app.py

@@ -0,0 +1,307 @@
+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")