Add complete tarot reading app with AI model integration

- Add app.py with Gradio interface and API endpoint
- Add requirements.txt with all necessary dependencies
- Add README.md with comprehensive documentation
- Add config.yaml for Space configuration
- Add test scripts for API testing
- Add deployment guide
- Integrate barissglc/tinyllama-tarot-v1 model for tarot predictions

DEPLOYMENT.md

@@ -0,0 +1,126 @@
+# 🚀 Deployment Guide for Tarot Space
+
+## Step 1: Create a Hugging Face Space
+
+1. Go to [Hugging Face Spaces](https://huggingface.co/new-space)
+2. Choose a name for your space (e.g., `your-username-tarot-reading`)
+3. Select **Gradio** as the SDK
+4. Choose **Public** or **Private** visibility
+5. Click **Create Space**
+
+## Step 2: Upload Files
+
+Upload these files to your Space:
+
+- `app.py` - Main application file
+- `requirements.txt` - Python dependencies
+- `README.md` - Space description and documentation
+- `config.yaml` - Space configuration (optional)
+
+## Step 3: Configure Space Settings
+
+In your Space settings:
+
+1. **Hardware**: Choose **CPU basic** (free) or **GPU** (paid) for faster inference
+2. **Variables**: No additional environment variables needed
+3. **Secrets**: No secrets required for this model
+
+## Step 4: Deploy
+
+1. The Space will automatically build and deploy
+2. Wait for the build to complete (usually 2-5 minutes)
+3. Your Space will be available at: `https://your-username-tarot-reading.hf.space`
+
+## Step 5: Test Your API
+
+Once deployed, you can test the API using the provided test script:
+
+```bash
+python test_api.py
+```
+
+Or test manually with curl:
+
+```bash
+curl -X POST "https://your-username-tarot-reading.hf.space/api/predict" \
+  -H "Content-Type: application/json" \
+  -d '{
+    "data": ["The Fool", "upright", "What should I focus on in my career?"]
+  }'
+```
+
+## API Endpoints
+
+### Main Interface
+- **URL**: `https://your-username-tarot-reading.hf.space`
+- **Method**: GET
+- **Description**: Interactive web interface
+
+### API Endpoint
+- **URL**: `https://your-username-tarot-reading.hf.space/api/predict`
+- **Method**: POST
+- **Content-Type**: application/json
+- **Body**:
+  ```json
+  {
+    "data": ["Card Name", "orientation", "question"]
+  }
+  ```
+
+### Response Format
+```json
+{
+  "data": "Your tarot reading response here..."
+}
+```
+
+## Troubleshooting
+
+### Common Issues
+
+1. **Model Loading Errors**
+   - Check if the model name is correct
+   - Ensure you have sufficient memory allocated
+   - Try reducing model precision if needed
+
+2. **API Not Working**
+   - Verify the Space is fully deployed
+   - Check the Space logs for errors
+   - Ensure the API endpoint URL is correct
+
+3. **Slow Responses**
+   - Consider upgrading to GPU hardware
+   - Optimize model loading (load once, reuse)
+   - Reduce max_new_tokens parameter
+
+### Performance Optimization
+
+1. **Model Loading**: The model loads once when the Space starts
+2. **Caching**: Responses are not cached by default
+3. **Concurrency**: Gradio handles multiple requests automatically
+
+## Monitoring
+
+- Check Space logs in the Hugging Face interface
+- Monitor API usage and performance
+- Set up alerts for errors if needed
+
+## Cost Considerations
+
+- **Free Tier**: CPU basic hardware, limited usage
+- **Paid Tiers**: GPU hardware, higher usage limits
+- **API Calls**: No additional cost for API usage
+
+## Security
+
+- The Space is public by default
+- No authentication required
+- Rate limiting handled by Hugging Face
+- Input validation in the application
+
+## Next Steps
+
+1. **Customize**: Modify the UI, add more features
+2. **Scale**: Upgrade hardware if needed
+3. **Integrate**: Use the API in your applications
+4. **Share**: Share your Space with others

README.md

@@ -1,12 +1,77 @@
 ---
-title: Tarot
-emoji: 🏢
-colorFrom: gray
-colorTo: green
+title: AI Tarot Reading
+emoji: 🔮
+colorFrom: purple
+colorTo: pink
 sdk: gradio
-sdk_version: 5.44.1
+sdk_version: 4.0.0
 app_file: app.py
 pinned: false
+license: apache-2.0
+short_description: Get AI-powered tarot card readings using a fine-tuned TinyLlama model
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# 🔮 AI Tarot Reading
+
+This Space provides AI-powered tarot card readings using a fine-tuned TinyLlama model specifically trained for tarot predictions.
+
+## Features
+
+- **AI-Powered Readings**: Get insightful tarot card interpretations using advanced language models
+- **Customizable Inputs**: Choose any tarot card and orientation (upright/reversed)
+- **Optional Questions**: Ask specific questions for personalized readings
+- **API Access**: Use the model programmatically via API endpoints
+
+## How to Use
+
+1. **Select a Card**: Enter the name of any tarot card (e.g., "The Fool", "The Magician")
+2. **Choose Orientation**: Select "upright" or "reversed"
+3. **Ask a Question** (Optional): Add a specific question for more personalized readings
+4. **Get Your Reading**: Click "Get Reading" to receive your AI-generated tarot interpretation
+
+## API Usage
+
+You can also use this model via API:
+
+```python
+import requests
+
+# Make a prediction
+response = requests.post(
+    "https://your-space-url.hf.space/api/predict",
+    json={
+        "data": ["The Fool", "upright", "What should I focus on in my career?"]
+    }
+)
+
+result = response.json()
+print(result["data"])  # Your tarot reading
+```
+
+## Model Information
+
+- **Base Model**: TinyLlama-1.1B-Chat-v1.0
+- **Fine-tuned for**: Tarot card predictions and interpretations
+- **Training Data**: Custom tarot dataset
+- **Capabilities**: Love, career, and general life guidance
+
+## Popular Tarot Cards
+
+- **The Fool** - New beginnings, innocence, spontaneity
+- **The Magician** - Manifestation, willpower, skill
+- **The High Priestess** - Intuition, mystery, subconscious
+- **The Empress** - Fertility, abundance, nature
+- **The Emperor** - Authority, structure, control
+- **The Lovers** - Love, relationships, choices
+- **The Chariot** - Determination, willpower, victory
+- **Strength** - Inner strength, courage, patience
+- **The Hermit** - Soul-searching, introspection, guidance
+- **Wheel of Fortune** - Change, cycles, destiny
+
+## Disclaimer
+
+This is an AI-generated tarot reading tool for entertainment purposes. The readings should not be considered as professional advice or predictions of the future.
+
+## License
+
+Apache 2.0

app.py

@@ -0,0 +1,148 @@
+import gradio as gr
+import torch
+from transformers import AutoTokenizer, AutoModelForCausalLM
+import json
+
+# Load the model and tokenizer
+model_name = "barissglc/tinyllama-tarot-v1"
+print(f"Loading model: {model_name}")
+
+try:
+    tokenizer = AutoTokenizer.from_pretrained(model_name)
+    model = AutoModelForCausalLM.from_pretrained(
+        model_name,
+        torch_dtype=torch.float16 if torch.cuda.is_available() else torch.float32,
+        device_map="auto" if torch.cuda.is_available() else None
+    )
+    print("Model loaded successfully!")
+except Exception as e:
+    print(f"Error loading model: {e}")
+    tokenizer = None
+    model = None
+
+def generate_tarot_response(card_name, orientation, question=""):
+    """
+    Generate a tarot reading based on card name, orientation, and optional question
+    """
+    if model is None or tokenizer is None:
+        return "Error: Model not loaded properly. Please try again later."
+
+    try:
+        # Format the input prompt
+        if question:
+            input_text = f"Card: {card_name}, orientation: {orientation}. Question: {question}. Explain in 3 short sentences."
+        else:
+            input_text = f"Card: {card_name}, orientation: {orientation}. Explain in 3 short sentences."
+
+        # Tokenize input
+        inputs = tokenizer(input_text, return_tensors="pt")
+
+        # Move to same device as model
+        if torch.cuda.is_available():
+            inputs = {k: v.cuda() for k, v in inputs.items()}
+
+        # Generate response
+        with torch.no_grad():
+            outputs = model.generate(
+                **inputs,
+                max_new_tokens=150,
+                temperature=0.7,
+                do_sample=True,
+                pad_token_id=tokenizer.eos_token_id,
+                eos_token_id=tokenizer.eos_token_id
+            )
+
+        # Decode response
+        response = tokenizer.decode(outputs[0], skip_special_tokens=True)
+
+        # Remove the input text from the response
+        if input_text in response:
+            response = response.replace(input_text, "").strip()
+
+        return response
+
+    except Exception as e:
+        return f"Error generating response: {str(e)}"
+
+def api_predict(card_name, orientation, question=""):
+    """
+    API endpoint for tarot predictions
+    """
+    result = generate_tarot_response(card_name, orientation, question)
+    return {
+        "card": card_name,
+        "orientation": orientation,
+        "question": question,
+        "reading": result
+    }
+
+# Create Gradio interface
+def create_interface():
+    with gr.Blocks(title="Tarot Reading with AI", theme=gr.themes.Soft()) as demo:
+        gr.Markdown("# 🔮 AI Tarot Reading")
+        gr.Markdown("Get insights from tarot cards using AI. Enter a card name, orientation, and optional question.")
+
+        with gr.Row():
+            with gr.Column():
+                card_name = gr.Textbox(
+                    label="Card Name",
+                    placeholder="e.g., The Fool, The Magician, The Lovers",
+                    value="The Fool"
+                )
+
+                orientation = gr.Dropdown(
+                    choices=["upright", "reversed"],
+                    label="Orientation",
+                    value="upright"
+                )
+
+                question = gr.Textbox(
+                    label="Question (Optional)",
+                    placeholder="e.g., What should I focus on in my career?",
+                    lines=2
+                )
+
+                generate_btn = gr.Button("🔮 Get Reading", variant="primary")
+
+            with gr.Column():
+                output = gr.Textbox(
+                    label="Tarot Reading",
+                    lines=8,
+                    interactive=False
+                )
+
+        # Example cards
+        gr.Markdown("### Popular Tarot Cards:")
+        gr.Markdown("""
+        - **The Fool** - New beginnings, innocence, spontaneity
+        - **The Magician** - Manifestation, willpower, skill
+        - **The High Priestess** - Intuition, mystery, subconscious
+        - **The Empress** - Fertility, abundance, nature
+        - **The Emperor** - Authority, structure, control
+        - **The Lovers** - Love, relationships, choices
+        - **The Chariot** - Determination, willpower, victory
+        - **Strength** - Inner strength, courage, patience
+        - **The Hermit** - Soul-searching, introspection, guidance
+        - **Wheel of Fortune** - Change, cycles, destiny
+        """)
+
+        # Event handlers
+        generate_btn.click(
+            fn=generate_tarot_response,
+            inputs=[card_name, orientation, question],
+            outputs=output
+        )
+
+        # API endpoint
+        demo.api_predict = api_predict
+
+    return demo
+
+# Create and launch the interface
+if __name__ == "__main__":
+    demo = create_interface()
+    demo.launch(
+        server_name="0.0.0.0",
+        server_port=7860,
+        share=True
+    )

config.yaml

@@ -0,0 +1,10 @@
+title: AI Tarot Reading
+emoji: 🔮
+colorFrom: purple
+colorTo: pink
+sdk: gradio
+sdk_version: 4.0.0
+app_file: app.py
+pinned: false
+license: apache-2.0
+short_description: Get AI-powered tarot card readings using a fine-tuned TinyLlama model

requirements.txt

@@ -0,0 +1,5 @@
+gradio>=4.0.0
+transformers>=4.37.0
+torch>=2.0.0
+accelerate>=0.20.0
+safetensors>=0.3.0

test_api.py

@@ -0,0 +1,77 @@
+#!/usr/bin/env python3
+"""
+Test script for the Tarot Space API
+"""
+
+import requests
+import json
+
+def test_tarot_api(space_url, card_name="The Fool", orientation="upright", question=""):
+    """
+    Test the tarot API endpoint
+    """
+    api_url = f"{space_url}/api/predict"
+
+    payload = {
+        "data": [card_name, orientation, question]
+    }
+
+    try:
+        response = requests.post(api_url, json=payload)
+        response.raise_for_status()
+
+        result = response.json()
+        return result
+
+    except requests.exceptions.RequestException as e:
+        return {"error": f"API request failed: {str(e)}"}
+
+def main():
+    # Replace with your actual Space URL
+    space_url = "https://your-username-tarot-space.hf.space"
+
+    print("🔮 Testing Tarot API...")
+    print(f"Space URL: {space_url}")
+    print("-" * 50)
+
+    # Test cases
+    test_cases = [
+        {
+            "card_name": "The Fool",
+            "orientation": "upright",
+            "question": "What should I focus on in my career?"
+        },
+        {
+            "card_name": "The Magician",
+            "orientation": "upright",
+            "question": ""
+        },
+        {
+            "card_name": "The Lovers",
+            "orientation": "reversed",
+            "question": "What does this mean for my relationship?"
+        }
+    ]
+
+    for i, test_case in enumerate(test_cases, 1):
+        print(f"\nTest {i}:")
+        print(f"Card: {test_case['card_name']}")
+        print(f"Orientation: {test_case['orientation']}")
+        print(f"Question: {test_case['question'] or 'None'}")
+
+        result = test_tarot_api(
+            space_url,
+            test_case['card_name'],
+            test_case['orientation'],
+            test_case['question']
+        )
+
+        if 'error' in result:
+            print(f"❌ Error: {result['error']}")
+        else:
+            print(f"✅ Response: {result.get('data', 'No data returned')}")
+
+        print("-" * 30)
+
+if __name__ == "__main__":
+    main()

test_curl.sh

@@ -0,0 +1,43 @@
+#!/bin/bash
+
+# Test script for Tarot Space API using curl
+# Replace YOUR_SPACE_URL with your actual Space URL
+
+SPACE_URL="https://your-username-tarot-reading.hf.space"
+API_URL="${SPACE_URL}/api/predict"
+
+echo "🔮 Testing Tarot Space API with curl"
+echo "Space URL: $SPACE_URL"
+echo "API URL: $API_URL"
+echo "=================================="
+
+# Test 1: Basic tarot reading
+echo "Test 1: Basic tarot reading (The Fool, upright)"
+curl -X POST "$API_URL" \
+  -H "Content-Type: application/json" \
+  -d '{
+    "data": ["The Fool", "upright", ""]
+  }' | jq '.'
+
+echo -e "\n=================================="
+
+# Test 2: Tarot reading with question
+echo "Test 2: Tarot reading with question (The Magician, upright)"
+curl -X POST "$API_URL" \
+  -H "Content-Type: application/json" \
+  -d '{
+    "data": ["The Magician", "upright", "What should I focus on in my career?"]
+  }' | jq '.'
+
+echo -e "\n=================================="
+
+# Test 3: Reversed card reading
+echo "Test 3: Reversed card reading (The Lovers, reversed)"
+curl -X POST "$API_URL" \
+  -H "Content-Type: application/json" \
+  -d '{
+    "data": ["The Lovers", "reversed", "What does this mean for my relationship?"]
+  }' | jq '.'
+
+echo -e "\n=================================="
+echo "✅ All tests completed!"