Upload 9 files

.gitignore

@@ -0,0 +1,167 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+pip-wheel-metadata/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+.python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# Streamlit
+.streamlit/
+
+# API Keys and secrets
+.secrets
+*.key
+api_keys.txt
+config_secrets.py
+
+# Images and uploads
+uploads/
+temp_images/
+*.jpg
+*.jpeg
+*.png
+*.gif
+*.bmp
+*.webp
+
+# Logs
+*.log
+logs/
+
+# IDE
+.vscode/
+.idea/
+*.swp
+*.swo
+*~
+
+# OS
+.DS_Store
+Thumbs.db
+
+# Temporary files
+*.tmp
+*.temp

README.md

@@ -0,0 +1,165 @@
+# 🏪 Shelf Photo Analyzer
+
+## Description
+
+An AI-powered tool for merchandisers and retail managers to instantly analyze product displays on store shelves. Simply upload a shelf photo, enter the product name, and get instant AI analysis with actionable recommendations to improve product placement and boost sales.
+
+## Features
+
+- 📸 **Photo Upload** - Support for JPG, PNG, WebP formats up to 10MB
+- 🔍 **Product Search** - AI-powered product detection and analysis
+- 🤖 **Smart Analysis** - Uses GPT-4 Vision API for accurate shelf assessment
+- 📊 **Compliance Scoring** - 1-10 score for product placement effectiveness
+- 💡 **Actionable Recommendations** - Specific suggestions with impact estimates
+- 📱 **Mobile Friendly** - Responsive design for field use
+- 📈 **Impact Forecasting** - Estimated sales improvement from changes
+
+## How to Use
+
+1. **Upload** a clear photo of the store shelf
+2. **Enter** the product name you want to analyze
+3. **Select** analysis depth (Basic/Detailed/Expert)
+4. **Click** "Analyze Photo" and wait 15-30 seconds
+5. **Review** results and follow the recommendations
+
+## Analysis Results
+
+The AI provides comprehensive analysis including:
+
+- ✅ **Product Detection** - Whether product is visible on shelf
+- 📦 **Facing Count** - Number of visible product units
+- 📍 **Shelf Position** - Top/middle/bottom placement
+- 💰 **Price Visibility** - Whether pricing is clearly shown  
+- 🧹 **Product Condition** - Cleanliness and damage assessment
+- 🏆 **Overall Score** - 1-10 rating for placement effectiveness
+- 🎯 **Confidence Level** - AI certainty in the analysis
+
+## Recommendations Engine
+
+Get prioritized action items with:
+
+- 🚨 **Priority Levels** - Critical, high, medium, low priorities
+- ⏱️ **Time Estimates** - How long each fix will take
+- 📈 **Impact Predictions** - Expected sales/visibility improvements
+- 🔧 **Difficulty Rating** - How easy each recommendation is to implement
+
+## Tech Stack
+
+- **Frontend:** Streamlit
+- **AI:** OpenAI GPT-4 Vision API
+- **Image Processing:** Pillow (PIL)
+- **Backend:** Python 3.9+
+- **Hosting:** Hugging Face Spaces
+
+## Setup Instructions
+
+### For Hugging Face Spaces Deployment
+
+1. **Fork/Clone** this repository
+2. **Create** a new Hugging Face Space
+3. **Select** "Streamlit" as the SDK
+4. **Upload** all files to your Space
+5. **Add** your OpenAI API key to Space secrets:
+   - Go to Settings → Repository secrets
+   - Add: `OPENAI_API_KEY = "your-api-key-here"`
+6. **Deploy** - your app will be live in minutes!
+
+### Local Development
+
+```bash
+# Clone repository
+git clone <repository-url>
+cd shelf-analyzer
+
+# Install dependencies  
+pip install -r requirements.txt
+
+# Set environment variable
+export OPENAI_API_KEY="your-api-key-here"
+
+# Run application
+streamlit run app.py
+```
+
+## Configuration
+
+The app uses the following configuration (in `config.py`):
+
+- **Max Image Size:** 10MB
+- **Supported Formats:** JPG, JPEG, PNG, WebP
+- **AI Model:** GPT-4 Vision Preview
+- **Analysis Timeout:** 60 seconds
+- **Max Retries:** 3 attempts
+
+## File Structure
+
+```
+shelf-analyzer/
+├── app.py                   # Main Streamlit application
+├── requirements.txt         # Python dependencies
+├── config.py               # Configuration settings
+├── README.md               # This file
+├── utils/
+│   ├── __init__.py
+│   ├── ai_analyzer.py      # AI analysis logic
+│   ├── recommendations.py  # Recommendation engine
+│   └── ui_components.py    # UI display components
+```
+
+## Usage Examples
+
+### Typical Use Cases
+
+- **Merchandisers:** Check product compliance during store visits
+- **Category Managers:** Audit shelf execution across locations  
+- **Store Managers:** Optimize product placement for better sales
+- **Retail Auditors:** Document and track display improvements
+
+### Sample Workflow
+
+1. Walk store aisles with smartphone/tablet
+2. Take photos of key product categories
+3. Analyze each product's shelf presence
+4. Follow AI recommendations immediately
+5. Re-analyze to confirm improvements
+
+## API Costs
+
+- **Hugging Face Hosting:** FREE ✨
+- **OpenAI API:** ~$0.01-0.04 per analysis
+- **Monthly Estimate:** $20-100 (depending on usage)
+
+## Limitations
+
+- Requires good lighting in photos
+- Works best with clear, unobstructed shelf views
+- AI accuracy depends on image quality
+- Currently supports single product analysis per photo
+
+## Future Roadmap
+
+### Phase 2
+- [ ] Batch analysis of multiple products
+- [ ] PDF report generation
+- [ ] Analysis history dashboard
+- [ ] Popular product presets
+
+### Phase 3  
+- [ ] Mobile app development
+- [ ] Real-time video analysis
+- [ ] Planogram compliance checking
+- [ ] Team collaboration features
+
+## Support
+
+For issues, questions, or feature requests:
+- Create an issue in this repository
+- Contact: [your-contact-info]
+
+## License
+
+This project is licensed under the MIT License - see the LICENSE file for details.
+
+---
+
+**Powered by OpenAI GPT-4 Vision API**

app.py

@@ -0,0 +1,219 @@
+import streamlit as st
+import os
+from PIL import Image
+import base64
+from io import BytesIO
+from utils.ai_analyzer import analyze_shelf_image
+from utils.recommendations import generate_recommendations
+from utils.ui_components import display_results, display_recommendations
+
+st.set_page_config(
+    page_title="Shelf Photo Analyzer",
+    page_icon="🏪",
+    layout="wide",
+    initial_sidebar_state="collapsed"
+)
+
+st.markdown("""
+<style>
+    .main-header {
+        font-size: 3rem;
+        color: #FF6B6B;
+        text-align: center;
+        margin-bottom: 1rem;
+    }
+    .subtitle {
+        font-size: 1.2rem;
+        text-align: center;
+        color: #666;
+        margin-bottom: 2rem;
+    }
+    .upload-section {
+        border: 2px dashed #FF6B6B;
+        border-radius: 10px;
+        padding: 2rem;
+        text-align: center;
+        margin: 1rem 0;
+    }
+    .results-container {
+        background-color: #f8f9fa;
+        border-radius: 10px;
+        padding: 1.5rem;
+        margin: 1rem 0;
+    }
+</style>
+""", unsafe_allow_html=True)
+
+def main():
+    st.markdown('<h1 class="main-header">🏪 Shelf Photo Analyzer</h1>', unsafe_allow_html=True)
+    st.markdown('<p class="subtitle">Błyskawiczna analiza ekspozycji produktów na półkach sklepowych przy użyciu AI</p>', unsafe_allow_html=True)
+    
+    # Initialize session state
+    if 'analysis_results' not in st.session_state:
+        st.session_state.analysis_results = None
+    if 'recommendations' not in st.session_state:
+        st.session_state.recommendations = None
+    if 'analysis_history' not in st.session_state:
+        st.session_state.analysis_history = []
+    if 'openai_api_key' not in st.session_state:
+        st.session_state.openai_api_key = ''
+
+    # API Key input
+    st.markdown("### 🔑 OpenAI API Configuration")
+    api_key_input = st.text_input(
+        "Enter your OpenAI API Key",
+        type="password",
+        value=st.session_state.openai_api_key,
+        placeholder="sk-...",
+        help="Your API key is stored only for this session and never saved permanently"
+    )
+    
+    if api_key_input != st.session_state.openai_api_key:
+        st.session_state.openai_api_key = api_key_input
+    
+    if not st.session_state.openai_api_key:
+        st.warning("⚠️ Please enter your OpenAI API key to use the analyzer. You can get one at: https://platform.openai.com/api-keys")
+        st.info("💡 **Tip:** Your API key is only stored temporarily in your browser session and is never saved permanently.")
+        return
+    
+    st.success("✅ API key configured successfully!")
+    st.markdown("---")
+
+    # Main interface
+    col1, col2 = st.columns([1, 1])
+    
+    with col1:
+        st.markdown("### 📸 Upload zdjęcia półki")
+        uploaded_file = st.file_uploader(
+            "Wybierz zdjęcie półki sklepowej",
+            type=['jpg', 'jpeg', 'png', 'webp'],
+            help="Obsługiwane formaty: JPG, PNG, WebP (max 10MB)"
+        )
+        
+        if uploaded_file is not None:
+            try:
+                image = Image.open(uploaded_file)
+                st.image(image, caption="Uploaded Image", use_column_width=True)
+                st.session_state.uploaded_image = image
+            except Exception as e:
+                st.error(f"Błąd przy wczytywaniu obrazu: {str(e)}")
+    
+    with col2:
+        st.markdown("### 🔍 Nazwa produktu")
+        product_name = st.text_input(
+            "Wpisz nazwę produktu do wyszukania",
+            placeholder="np. Coca-Cola 0.5L, Milka czekolada...",
+            help="Wpisz konkretną nazwę produktu, który chcesz znaleźć na półce"
+        )
+        
+        st.markdown("### ⚙️ Opcje analizy")
+        analysis_depth = st.selectbox(
+            "Poziom szczegółowości",
+            ["Podstawowy", "Szczegółowy", "Ekspercki"],
+            help="Wybierz poziom analizy - im wyższy, tym więcej szczegółów"
+        )
+
+    # Analysis button
+    if st.button("🚀 Analizuj zdjęcie", type="primary", use_container_width=True):
+        if not st.session_state.openai_api_key:
+            st.error("⚠️ Proszę najpierw wprowadzić klucz API!")
+        elif uploaded_file is None:
+            st.error("⚠️ Proszę najpierw wgrać zdjęcie!")
+        elif not product_name.strip():
+            st.error("⚠️ Proszę wpisać nazwę produktu!")
+        else:
+            with st.spinner("🤖 Analizuję zdjęcie... To może potrwać do 30 sekund"):
+                try:
+                    # Convert image to base64 for API
+                    buffered = BytesIO()
+                    image.save(buffered, format="JPEG")
+                    image_base64 = base64.b64encode(buffered.getvalue()).decode()
+                    
+                    # Analyze image
+                    analysis_results = analyze_shelf_image(
+                        image_base64, 
+                        product_name, 
+                        analysis_depth
+                    )
+                    
+                    if analysis_results:
+                        st.session_state.analysis_results = analysis_results
+                        st.session_state.recommendations = generate_recommendations(analysis_results)
+                        
+                        # Add to history
+                        st.session_state.analysis_history.append({
+                            'product_name': product_name,
+                            'analysis_date': st.session_state.get('current_time', 'Unknown'),
+                            'results': analysis_results
+                        })
+                        
+                        st.success("✅ Analiza zakończona pomyślnie!")
+                        st.rerun()
+                    else:
+                        st.error("❌ Wystąpił błąd podczas analizy. Spróbuj ponownie.")
+                        
+                except Exception as e:
+                    st.error(f"❌ Błąd podczas analizy: {str(e)}")
+
+    # Display results
+    if st.session_state.analysis_results:
+        st.markdown("---")
+        st.markdown("## 📊 Wyniki analizy")
+        
+        # Display analysis results
+        display_results(st.session_state.analysis_results, product_name)
+        
+        # Display recommendations
+        if st.session_state.recommendations:
+            st.markdown("## 💡 Rekomendacje")
+            display_recommendations(st.session_state.recommendations)
+            
+            # Export options
+            col1, col2, col3 = st.columns(3)
+            with col1:
+                if st.button("📄 Eksportuj do PDF"):
+                    st.info("🚧 Funkcja w przygotowaniu")
+            with col2:
+                if st.button("📧 Wyślij email"):
+                    st.info("🚧 Funkcja w przygotowaniu")
+            with col3:
+                if st.button("🔄 Nowa analiza"):
+                    st.session_state.analysis_results = None
+                    st.session_state.recommendations = None
+                    st.rerun()
+
+    # Sidebar with history and info
+    with st.sidebar:
+        st.markdown("## 📈 Historia analiz")
+        if st.session_state.analysis_history:
+            for i, analysis in enumerate(reversed(st.session_state.analysis_history[-5:])):
+                with st.expander(f"{analysis['product_name']} ({analysis['analysis_date']})"):
+                    score = analysis['results'].get('overall_score', 'N/A')
+                    st.write(f"Ocena: {score}/10")
+                    if analysis['results'].get('product_found'):
+                        st.write("✅ Produkt znaleziony")
+                    else:
+                        st.write("❌ Produkt nie znaleziony")
+        else:
+            st.write("Brak historii analiz")
+        
+        st.markdown("---")
+        st.markdown("## ℹ️ Informacje")
+        st.markdown("""
+        **Jak używać:**
+        1. Wgraj zdjęcie półki
+        2. Wpisz nazwę produktu
+        3. Kliknij "Analizuj"
+        4. Otrzymaj rekomendacje
+        
+        **Wskazówki:**
+        - Rób zdjęcia z dobrem oświetleniu
+        - Upewnij się, że produkty są widoczne
+        - Używaj konkretnych nazw produktów
+        """)
+        
+        st.markdown("---")
+        st.markdown("**Powered by OpenAI GPT-4 Vision**")
+
+if __name__ == "__main__":
+    main()

config.py

@@ -0,0 +1,66 @@
+import streamlit as st
+import os
+
+# OpenAI Configuration
+def get_openai_api_key():
+    """Get OpenAI API key from user input in session state"""
+    api_key = st.session_state.get('openai_api_key', '')
+    if not api_key:
+        return None
+    return api_key
+
+# Application Configuration
+MAX_IMAGE_SIZE = 10 * 1024 * 1024  # 10MB
+SUPPORTED_FORMATS = ['jpg', 'jpeg', 'png', 'webp']
+AI_MODEL = "gpt-4-vision-preview"
+
+# Analysis Settings
+ANALYSIS_TIMEOUT = 60  # seconds
+MAX_RETRY_ATTEMPTS = 3
+
+# UI Configuration
+PRIMARY_COLOR = "#FF6B6B"
+BACKGROUND_COLOR = "#FFFFFF"
+SECONDARY_BACKGROUND_COLOR = "#F0F2F6"
+TEXT_COLOR = "#262730"
+
+# Prompt Templates
+ANALYSIS_PROMPT_TEMPLATE = """
+Jesteś ekspertem w analizie ekspozycji produktów w sklepach detalicznych. 
+Przeanalizuj to zdjęcie półki pod kątem obecności produktu: "{product_name}".
+
+Zwróć wyniki w formacie JSON z następującymi polami:
+{{
+    "product_found": true/false,
+    "facing_count": liczba_widocznych_sztuk,
+    "shelf_position": "top"/"middle"/"bottom",
+    "price_visible": true/false,
+    "product_condition": "good"/"dusty"/"damaged",
+    "overall_score": ocena_1_10,
+    "confidence": pewność_0_1,
+    "description": "szczegółowy_opis_sytuacji",
+    "competitors_nearby": ["lista_konkurencyjnych_produktów"],
+    "shelf_share": procent_zajętości_półki
+}}
+
+Poziom analizy: {analysis_depth}
+"""
+
+RECOMMENDATIONS_RULES = {
+    "position": {
+        "eye_level": "Przenieś produkty na poziom oczu (zwiększa sprzedaż o 30%)",
+        "visibility": "Popraw widoczność produktów"
+    },
+    "quantity": {
+        "increase_facings": "Dodaj dodatkowe facings",
+        "restock": "Uzupełnij brakujące produkty"
+    },
+    "condition": {
+        "cleaning": "Wyczyść produkty i opakowania",
+        "replace_damaged": "Wymień uszkodzone produkty"
+    },
+    "pricing": {
+        "add_price": "Dodaj widoczną cenę",
+        "update_price": "Zaktualizuj cenę"
+    }
+}

requirements.txt

@@ -0,0 +1,6 @@
+streamlit>=1.28.0
+Pillow>=10.0.0
+openai>=1.3.0
+pandas>=2.0.0
+numpy>=1.24.0
+requests>=2.31.0

utils/__init__.py

@@ -0,0 +1 @@
+# Utils package for Shelf Photo Analyzer

utils/ai_analyzer.py

@@ -0,0 +1,181 @@
+import openai
+import streamlit as st
+import json
+from typing import Dict, Optional
+from config import get_openai_api_key, ANALYSIS_PROMPT_TEMPLATE, AI_MODEL
+
+def analyze_shelf_image(image_base64: str, product_name: str, analysis_depth: str = "Podstawowy") -> Optional[Dict]:
+    """
+    Analyze shelf image using OpenAI GPT-4 Vision API
+    
+    Args:
+        image_base64: Base64 encoded image
+        product_name: Name of product to search for
+        analysis_depth: Level of analysis detail
+    
+    Returns:
+        Dictionary with analysis results or None if failed
+    """
+    try:
+        # Get API key and validate
+        api_key = get_openai_api_key()
+        if not api_key:
+            st.error("⚠️ OpenAI API key not configured!")
+            return None
+        
+        # Initialize OpenAI client
+        client = openai.OpenAI(api_key=api_key)
+        
+        # Prepare the prompt
+        prompt = ANALYSIS_PROMPT_TEMPLATE.format(
+            product_name=product_name,
+            analysis_depth=analysis_depth
+        )
+        
+        # Make API call
+        response = client.chat.completions.create(
+            model=AI_MODEL,
+            messages=[
+                {
+                    "role": "user",
+                    "content": [
+                        {
+                            "type": "text",
+                            "text": prompt
+                        },
+                        {
+                            "type": "image_url",
+                            "image_url": {
+                                "url": f"data:image/jpeg;base64,{image_base64}",
+                                "detail": "high"
+                            }
+                        }
+                    ]
+                }
+            ],
+            max_tokens=1500,
+            temperature=0.1
+        )
+        
+        # Parse response
+        content = response.choices[0].message.content
+        
+        # Try to extract JSON from response
+        try:
+            # Find JSON in the response
+            start_idx = content.find('{')
+            end_idx = content.rfind('}') + 1
+            
+            if start_idx != -1 and end_idx != -1:
+                json_str = content[start_idx:end_idx]
+                analysis_results = json.loads(json_str)
+                
+                # Validate required fields
+                required_fields = ['product_found', 'overall_score', 'confidence']
+                for field in required_fields:
+                    if field not in analysis_results:
+                        st.warning(f"Missing required field: {field}")
+                        analysis_results[field] = get_default_value(field)
+                
+                # Ensure proper data types
+                analysis_results = normalize_analysis_results(analysis_results)
+                
+                return analysis_results
+            else:
+                st.error("Could not find JSON in AI response")
+                return create_fallback_result(product_name, content)
+                
+        except json.JSONDecodeError as e:
+            st.error(f"Failed to parse AI response as JSON: {str(e)}")
+            return create_fallback_result(product_name, content)
+            
+    except Exception as e:
+        st.error(f"Error during AI analysis: {str(e)}")
+        return None
+
+def normalize_analysis_results(results: Dict) -> Dict:
+    """Normalize analysis results to ensure proper data types"""
+    try:
+        # Ensure boolean fields
+        bool_fields = ['product_found', 'price_visible']
+        for field in bool_fields:
+            if field in results:
+                if isinstance(results[field], str):
+                    results[field] = results[field].lower() in ['true', '1', 'yes', 'tak']
+                else:
+                    results[field] = bool(results[field])
+        
+        # Ensure numeric fields
+        if 'overall_score' in results:
+            try:
+                results['overall_score'] = max(1, min(10, int(float(results['overall_score']))))
+            except:
+                results['overall_score'] = 5
+        
+        if 'confidence' in results:
+            try:
+                results['confidence'] = max(0.0, min(1.0, float(results['confidence'])))
+            except:
+                results['confidence'] = 0.5
+        
+        if 'facing_count' in results:
+            try:
+                results['facing_count'] = max(0, int(results['facing_count']))
+            except:
+                results['facing_count'] = 0
+        
+        if 'shelf_share' in results:
+            try:
+                results['shelf_share'] = max(0, min(100, float(results['shelf_share'])))
+            except:
+                results['shelf_share'] = 0
+        
+        # Ensure string fields
+        string_fields = ['shelf_position', 'product_condition', 'description']
+        for field in string_fields:
+            if field in results and not isinstance(results[field], str):
+                results[field] = str(results[field])
+        
+        # Ensure list fields
+        if 'competitors_nearby' in results and not isinstance(results['competitors_nearby'], list):
+            results['competitors_nearby'] = []
+        
+        return results
+        
+    except Exception as e:
+        st.warning(f"Error normalizing results: {str(e)}")
+        return results
+
+def get_default_value(field: str):
+    """Get default value for missing field"""
+    defaults = {
+        'product_found': False,
+        'facing_count': 0,
+        'shelf_position': 'unknown',
+        'price_visible': False,
+        'product_condition': 'unknown',
+        'overall_score': 5,
+        'confidence': 0.5,
+        'description': 'Analysis incomplete',
+        'competitors_nearby': [],
+        'shelf_share': 0
+    }
+    return defaults.get(field, None)
+
+def create_fallback_result(product_name: str, ai_response: str) -> Dict:
+    """Create fallback result when JSON parsing fails"""
+    # Try to extract basic information from text response
+    product_found = any(word in ai_response.lower() for word in ['found', 'visible', 'present', 'znaleziono', 'widoczny'])
+    
+    return {
+        'product_found': product_found,
+        'facing_count': 1 if product_found else 0,
+        'shelf_position': 'unknown',
+        'price_visible': 'cena' in ai_response.lower() or 'price' in ai_response.lower(),
+        'product_condition': 'good',
+        'overall_score': 6 if product_found else 3,
+        'confidence': 0.6,
+        'description': f"Analysis of {product_name}: {ai_response[:200]}...",
+        'competitors_nearby': [],
+        'shelf_share': 10 if product_found else 0
+    }

utils/recommendations.py

@@ -0,0 +1,213 @@
+from typing import Dict, List
+from config import RECOMMENDATIONS_RULES
+
+def generate_recommendations(analysis_results: Dict) -> List[Dict]:
+    """
+    Generate actionable recommendations based on analysis results
+    
+    Args:
+        analysis_results: Dictionary with analysis results from AI
+        
+    Returns:
+        List of recommendation dictionaries
+    """
+    recommendations = []
+    
+    if not analysis_results:
+        return recommendations
+    
+    # Product not found recommendations
+    if not analysis_results.get('product_found', False):
+        recommendations.append({
+            'type': 'critical',
+            'priority': 1,
+            'title': '🚨 Produkt nie znaleziony',
+            'description': 'Produkt nie jest widoczny na półce lub jest niedostępny.',
+            'action': 'Uzupełnij asortyment lub sprawdź lokalizację produktu',
+            'estimated_impact': '+100% dostępności',
+            'time_to_fix': '5-15 minut',
+            'difficulty': 'Łatwe'
+        })
+        return recommendations
+    
+    # Position recommendations
+    shelf_position = analysis_results.get('shelf_position', '').lower()
+    if shelf_position in ['bottom', 'dół', 'dolna']:
+        recommendations.append({
+            'type': 'position',
+            'priority': 2,
+            'title': '📈 Przenieś na poziom oczu',
+            'description': 'Produkt znajduje się na dolnej półce, co znacznie zmniejsza widoczność.',
+            'action': 'Przenieś produkty na poziom oczu (120-160cm)',
+            'estimated_impact': '+30% sprzedaży',
+            'time_to_fix': '2-3 minuty',
+            'difficulty': 'Łatwe'
+        })
+    elif shelf_position in ['top', 'góra', 'górna']:
+        recommendations.append({
+            'type': 'position',
+            'priority': 3,
+            'title': '👁️ Popraw widoczność',
+            'description': 'Produkt na górnej półce - rozważ przeniesienie lub dodatkowe oznakowanie.',
+            'action': 'Przenieś na środkową półkę lub dodaj shelf talker',
+            'estimated_impact': '+20% widoczności',
+            'time_to_fix': '2-3 minuty',
+            'difficulty': 'Łatwe'
+        })
+    
+    # Facing count recommendations
+    facing_count = analysis_results.get('facing_count', 0)
+    if facing_count == 1:
+        recommendations.append({
+            'type': 'quantity',
+            'priority': 3,
+            'title': '➕ Zwiększ liczbę facings',
+            'description': 'Tylko jeden facing - zwiększenie do 2-3 poprawia widoczność.',
+            'action': 'Dodaj 1-2 dodatkowe facings',
+            'estimated_impact': '+15% widoczności',
+            'time_to_fix': '1-2 minuty',
+            'difficulty': 'Bardzo łatwe'
+        })
+    elif facing_count == 0:
+        recommendations.append({
+            'type': 'quantity',
+            'priority': 1,
+            'title': '🔄 Uzupełnij produkty',
+            'description': 'Brak produktów na półce.',
+            'action': 'Uzupełnij asortyment z magazynu',
+            'estimated_impact': '+100% dostępności',
+            'time_to_fix': '5-10 minut',
+            'difficulty': 'Łatwe'
+        })
+    
+    # Price visibility recommendations
+    if not analysis_results.get('price_visible', False):
+        recommendations.append({
+            'type': 'pricing',
+            'priority': 2,
+            'title': '💰 Dodaj widoczną cenę',
+            'description': 'Brak widocznej ceny może zniechęcać klientów.',
+            'action': 'Dodaj lub popraw czytelność cenówki',
+            'estimated_impact': '+10% konwersji',
+            'time_to_fix': '1-2 minuty',
+            'difficulty': 'Bardzo łatwe'
+        })
+    
+    # Product condition recommendations
+    condition = analysis_results.get('product_condition', '').lower()
+    if condition in ['dusty', 'zakurzony']:
+        recommendations.append({
+            'type': 'condition',
+            'priority': 4,
+            'title': '🧹 Wyczyść produkty',
+            'description': 'Produkty wyglądają na zakurzone, co wpływa na postrzeganie jakości.',
+            'action': 'Wyczyść produkty i opakowania',
+            'estimated_impact': '+5% percepcji jakości',
+            'time_to_fix': '2-3 minuty',
+            'difficulty': 'Bardzo łatwe'
+        })
+    elif condition in ['damaged', 'uszkodzony']:
+        recommendations.append({
+            'type': 'condition',
+            'priority': 1,
+            'title': '⚠️ Wymień uszkodzone produkty',
+            'description': 'Uszkodzone produkty negatywnie wpływają na wizerunek marki.',
+            'action': 'Usuń uszkodzone produkty i zastąp nowymi',
+            'estimated_impact': '+15% percepcji marki',
+            'time_to_fix': '3-5 minut',
+            'difficulty': 'Łatwe'
+        })
+    
+    # Competition recommendations
+    competitors = analysis_results.get('competitors_nearby', [])
+    if len(competitors) > 3:
+        recommendations.append({
+            'type': 'competition',
+            'priority': 3,
+            'title': '🎯 Zwiększ wyróżnienie',
+            'description': f'Silna konkurencja w pobliżu ({len(competitors)} produktów konkurencyjnych).',
+            'action': 'Dodaj materiały POS lub zwiększ liczbę facings',
+            'estimated_impact': '+20% uwagi klientów',
+            'time_to_fix': '5-10 minut',
+            'difficulty': 'Średnie'
+        })
+    
+    # Shelf share recommendations
+    shelf_share = analysis_results.get('shelf_share', 0)
+    if shelf_share < 10:
+        recommendations.append({
+            'type': 'share',
+            'priority': 2,
+            'title': '📊 Zwiększ udział w półce',
+            'description': f'Niski udział w półce ({shelf_share}%). Rozważ negocjacje z menedżerem kategorii.',
+            'action': 'Zwiększ liczbę facings lub wynegocjuj lepszą przestrzeń',
+            'estimated_impact': '+25% widoczności',
+            'time_to_fix': '10-30 minut',
+            'difficulty': 'Trudne'
+        })
+    
+    # Overall score recommendations
+    overall_score = analysis_results.get('overall_score', 5)
+    if overall_score < 4:
+        recommendations.append({
+            'type': 'general',
+            'priority': 1,
+            'title': '🚀 Kompleksowa poprawa',
+            'description': 'Niska ogólna ocena ekspozycji wymaga kompleksowej poprawy.',
+            'action': 'Zastosuj wszystkie powyższe rekomendacje w kolejności priorytetów',
+            'estimated_impact': '+50% ogólnej efektywności',
+            'time_to_fix': '15-30 minut',
+            'difficulty': 'Średnie'
+        })
+    
+    # Sort recommendations by priority
+    recommendations.sort(key=lambda x: x['priority'])
+    
+    return recommendations
+
+def calculate_total_impact(recommendations: List[Dict]) -> Dict:
+    """
+    Calculate estimated total impact of all recommendations
+    
+    Args:
+        recommendations: List of recommendation dictionaries
+        
+    Returns:
+        Dictionary with total impact estimates
+    """
+    total_time = 0
+    impact_categories = {
+        'sprzedaż': [],
+        'widoczność': [],
+        'dostępność': [],
+        'jakość': []
+    }
+    
+    for rec in recommendations:
+        # Extract time (assuming format like "2-3 minuty")
+        time_str = rec.get('time_to_fix', '0')
+        try:
+            # Extract first number from time string
+            time_parts = time_str.split('-')
+            if time_parts:
+                total_time += int(''.join(filter(str.isdigit, time_parts[0])))
+        except:
+            total_time += 5  # Default 5 minutes
+        
+        # Categorize impact
+        impact = rec.get('estimated_impact', '')
+        if 'sprzedaż' in impact.lower():
+            impact_categories['sprzedaż'].append(impact)
+        elif 'widoczność' in impact.lower():
+            impact_categories['widoczność'].append(impact)
+        elif 'dostępność' in impact.lower():
+            impact_categories['dostępność'].append(impact)
+        elif any(word in impact.lower() for word in ['jakość', 'percepcj']):
+            impact_categories['jakość'].append(impact)
+    
+    return {
+        'total_time_minutes': total_time,
+        'impact_categories': impact_categories,
+        'total_recommendations': len(recommendations),
+        'high_priority_count': len([r for r in recommendations if r['priority'] <= 2])
+    }

utils/ui_components.py

@@ -0,0 +1,302 @@
+import streamlit as st
+from typing import Dict, List
+from utils.recommendations import calculate_total_impact
+
+def display_results(analysis_results: Dict, product_name: str):
+    """Display analysis results in a formatted way"""
+    
+    col1, col2, col3 = st.columns(3)
+    
+    with col1:
+        # Overall score
+        score = analysis_results.get('overall_score', 5)
+        if score >= 8:
+            score_color = "🟢"
+            score_text = "Excellent"
+        elif score >= 6:
+            score_color = "🟡"
+            score_text = "Good"
+        else:
+            score_color = "🔴"
+            score_text = "Needs Improvement"
+        
+        st.metric(
+            label="Overall Score",
+            value=f"{score}/10",
+            delta=score_text,
+            help="Overall assessment of product placement"
+        )
+    
+    with col2:
+        # Confidence
+        confidence = analysis_results.get('confidence', 0.5)
+        confidence_pct = int(confidence * 100)
+        st.metric(
+            label="AI Confidence",
+            value=f"{confidence_pct}%",
+            help="How confident the AI is in this analysis"
+        )
+    
+    with col3:
+        # Product found status
+        found = analysis_results.get('product_found', False)
+        status = "✅ Found" if found else "❌ Not Found"
+        st.metric(
+            label="Product Status",
+            value=status,
+            help="Whether the product was detected on the shelf"
+        )
+    
+    st.markdown("---")
+    
+    # Detailed information
+    col1, col2 = st.columns(2)
+    
+    with col1:
+        st.markdown("### 📊 Product Details")
+        
+        # Facing count
+        facing_count = analysis_results.get('facing_count', 0)
+        st.info(f"**Facings:** {facing_count} visible units")
+        
+        # Shelf position
+        position = analysis_results.get('shelf_position', 'Unknown')
+        position_emoji = {
+            'top': '⬆️',
+            'middle': '➡️', 
+            'bottom': '⬇️',
+            'górna': '⬆️',
+            'środkowa': '➡️',
+            'dolna': '⬇️'
+        }.get(position.lower(), '❓')
+        st.info(f"**Position:** {position_emoji} {position.title()}")
+        
+        # Price visibility
+        price_visible = analysis_results.get('price_visible', False)
+        price_status = "✅ Visible" if price_visible else "❌ Not visible"
+        st.info(f"**Price:** {price_status}")
+    
+    with col2:
+        st.markdown("### 🔍 Quality Assessment")
+        
+        # Product condition
+        condition = analysis_results.get('product_condition', 'Unknown')
+        condition_emoji = {
+            'good': '✅',
+            'dusty': '🧹',
+            'damaged': '⚠️',
+            'dobry': '✅',
+            'zakurzony': '🧹',
+            'uszkodzony': '⚠️'
+        }.get(condition.lower(), '❓')
+        st.info(f"**Condition:** {condition_emoji} {condition.title()}")
+        
+        # Shelf share
+        shelf_share = analysis_results.get('shelf_share', 0)
+        if shelf_share > 0:
+            st.info(f"**Shelf Share:** {shelf_share}% of shelf space")
+        
+        # Competitors
+        competitors = analysis_results.get('competitors_nearby', [])
+        if competitors:
+            st.info(f"**Nearby Competitors:** {len(competitors)} products")
+    
+    # Description
+    description = analysis_results.get('description', '')
+    if description:
+        st.markdown("### 📝 Analysis Details")
+        st.markdown(f"> {description}")
+
+def display_recommendations(recommendations: List[Dict]):
+    """Display recommendations in a formatted way"""
+    
+    if not recommendations:
+        st.info("No specific recommendations generated.")
+        return
+    
+    # Calculate total impact
+    impact_summary = calculate_total_impact(recommendations)
+    
+    # Display summary metrics
+    col1, col2, col3, col4 = st.columns(4)
+    
+    with col1:
+        st.metric(
+            "Total Recommendations",
+            impact_summary['total_recommendations'],
+            help="Number of actionable recommendations"
+        )
+    
+    with col2:
+        st.metric(
+            "High Priority",
+            impact_summary['high_priority_count'],
+            help="Critical issues requiring immediate attention"
+        )
+    
+    with col3:
+        st.metric(
+            "Estimated Time",
+            f"{impact_summary['total_time_minutes']} min",
+            help="Total time needed to implement all changes"
+        )
+    
+    with col4:
+        # Calculate difficulty distribution
+        difficulties = [r.get('difficulty', 'Unknown') for r in recommendations]
+        easy_count = difficulties.count('Bardzo łatwe') + difficulties.count('Łatwe')
+        difficulty_text = f"{easy_count}/{len(recommendations)} Easy"
+        st.metric(
+            "Difficulty",
+            difficulty_text,
+            help="How many recommendations are easy to implement"
+        )
+    
+    st.markdown("---")
+    
+    # Group recommendations by priority
+    high_priority = [r for r in recommendations if r.get('priority', 5) <= 2]
+    medium_priority = [r for r in recommendations if r.get('priority', 5) == 3]
+    low_priority = [r for r in recommendations if r.get('priority', 5) >= 4]
+    
+    # Display high priority recommendations
+    if high_priority:
+        st.markdown("### 🚨 High Priority (Do First)")
+        for rec in high_priority:
+            display_recommendation_card(rec)
+    
+    # Display medium priority recommendations
+    if medium_priority:
+        st.markdown("### ⚡ Medium Priority")
+        for rec in medium_priority:
+            display_recommendation_card(rec)
+    
+    # Display low priority recommendations  
+    if low_priority:
+        st.markdown("### 💡 Additional Improvements")
+        for rec in low_priority:
+            display_recommendation_card(rec)
+
+def display_recommendation_card(recommendation: Dict):
+    """Display a single recommendation as a card"""
+    
+    # Priority styling
+    priority = recommendation.get('priority', 5)
+    if priority <= 2:
+        border_color = "#ff4b4b"  # Red
+    elif priority == 3:
+        border_color = "#ffa500"  # Orange
+    else:
+        border_color = "#1f77b4"  # Blue
+    
+    # Card styling
+    st.markdown(f"""
+    <div style="
+        border: 2px solid {border_color};
+        border-radius: 10px;
+        padding: 15px;
+        margin: 10px 0;
+        background-color: white;
+    ">
+    </div>
+    """, unsafe_allow_html=True)
+    
+    with st.container():
+        col1, col2 = st.columns([3, 1])
+        
+        with col1:
+            # Title and description
+            title = recommendation.get('title', 'Recommendation')
+            st.markdown(f"**{title}**")
+            
+            description = recommendation.get('description', '')
+            if description:
+                st.markdown(f"*{description}*")
+            
+            # Action
+            action = recommendation.get('action', '')
+            if action:
+                st.markdown(f"**Action:** {action}")
+        
+        with col2:
+            # Metrics
+            impact = recommendation.get('estimated_impact', '')
+            if impact:
+                st.markdown(f"📈 **{impact}**")
+            
+            time_to_fix = recommendation.get('time_to_fix', '')
+            if time_to_fix:
+                st.markdown(f"⏱️ {time_to_fix}")
+            
+            difficulty = recommendation.get('difficulty', '')
+            if difficulty:
+                difficulty_emoji = {
+                    'Bardzo łatwe': '🟢',
+                    'Łatwe': '🟡', 
+                    'Średnie': '🟠',
+                    'Trudne': '🔴'
+                }.get(difficulty, '⚪')
+                st.markdown(f"{difficulty_emoji} {difficulty}")
+
+def display_analysis_history(history: List[Dict]):
+    """Display analysis history"""
+    
+    if not history:
+        st.info("No analysis history available.")
+        return
+    
+    for i, analysis in enumerate(reversed(history[-10:])):  # Show last 10
+        with st.expander(
+            f"{analysis.get('product_name', 'Unknown')} - {analysis.get('analysis_date', 'Unknown')}"
+        ):
+            results = analysis.get('results', {})
+            
+            col1, col2, col3 = st.columns(3)
+            
+            with col1:
+                score = results.get('overall_score', 'N/A')
+                st.metric("Score", f"{score}/10")
+            
+            with col2:
+                found = results.get('product_found', False)
+                status = "Found" if found else "Not Found"
+                st.metric("Status", status)
+            
+            with col3:
+                facings = results.get('facing_count', 0)
+                st.metric("Facings", facings)
+            
+            description = results.get('description', '')
+            if description:
+                st.markdown(f"**Description:** {description[:200]}...")
+
+def create_export_summary(analysis_results: Dict, recommendations: List[Dict], product_name: str) -> str:
+    """Create a summary for export purposes"""
+    
+    summary = f"""
+# Shelf Analysis Report - {product_name}
+
+## Analysis Results
+- **Overall Score:** {analysis_results.get('overall_score', 'N/A')}/10
+- **Product Found:** {'Yes' if analysis_results.get('product_found') else 'No'}
+- **Facing Count:** {analysis_results.get('facing_count', 0)}
+- **Shelf Position:** {analysis_results.get('shelf_position', 'Unknown')}
+- **Price Visible:** {'Yes' if analysis_results.get('price_visible') else 'No'}
+- **Product Condition:** {analysis_results.get('product_condition', 'Unknown')}
+- **AI Confidence:** {int(analysis_results.get('confidence', 0.5) * 100)}%
+
+## Recommendations ({len(recommendations)})
+"""
+    
+    for i, rec in enumerate(recommendations, 1):
+        summary += f"""
+### {i}. {rec.get('title', 'Recommendation')}
+- **Priority:** {rec.get('priority', 'N/A')}
+- **Description:** {rec.get('description', '')}
+- **Action:** {rec.get('action', '')}
+- **Estimated Impact:** {rec.get('estimated_impact', '')}
+- **Time to Fix:** {rec.get('time_to_fix', '')}
+- **Difficulty:** {rec.get('difficulty', '')}
+"""
+    
+    return summary