Upload folder using huggingface_hub

.gitignore

@@ -0,0 +1,61 @@
+# Python
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# Virtual environments
+venv/
+env/
+ENV/
+.venv/
+
+# Gradio
+gradio_cached_examples/
+flagged/
+
+# Model cache
+.cache/
+huggingface/
+transformers_cache/
+
+# IDE
+.vscode/
+.idea/
+*.swp
+*.swo
+
+# OS
+.DS_Store
+Thumbs.db
+
+# Logs
+*.log
+
+# Temporary files
+tmp/
+temp/
+*.tmp
+
+# Images (if you don't want to commit test images)
+# *.jpg
+# *.png
+# *.jpeg 

.gradio/certificate.pem

@@ -0,0 +1,31 @@
+-----BEGIN CERTIFICATE-----
+MIIFazCCA1OgAwIBAgIRAIIQz7DSQONZRGPgu2OCiwAwDQYJKoZIhvcNAQELBQAw
+TzELMAkGA1UEBhMCVVMxKTAnBgNVBAoTIEludGVybmV0IFNlY3VyaXR5IFJlc2Vh
+cmNoIEdyb3VwMRUwEwYDVQQDEwxJU1JHIFJvb3QgWDEwHhcNMTUwNjA0MTEwNDM4
+WhcNMzUwNjA0MTEwNDM4WjBPMQswCQYDVQQGEwJVUzEpMCcGA1UEChMgSW50ZXJu
+ZXQgU2VjdXJpdHkgUmVzZWFyY2ggR3JvdXAxFTATBgNVBAMTDElTUkcgUm9vdCBY
+MTCCAiIwDQYJKoZIhvcNAQEBBQADggIPADCCAgoCggIBAK3oJHP0FDfzm54rVygc
+h77ct984kIxuPOZXoHj3dcKi/vVqbvYATyjb3miGbESTtrFj/RQSa78f0uoxmyF+
+0TM8ukj13Xnfs7j/EvEhmkvBioZxaUpmZmyPfjxwv60pIgbz5MDmgK7iS4+3mX6U
+A5/TR5d8mUgjU+g4rk8Kb4Mu0UlXjIB0ttov0DiNewNwIRt18jA8+o+u3dpjq+sW
+T8KOEUt+zwvo/7V3LvSye0rgTBIlDHCNAymg4VMk7BPZ7hm/ELNKjD+Jo2FR3qyH
+B5T0Y3HsLuJvW5iB4YlcNHlsdu87kGJ55tukmi8mxdAQ4Q7e2RCOFvu396j3x+UC
+B5iPNgiV5+I3lg02dZ77DnKxHZu8A/lJBdiB3QW0KtZB6awBdpUKD9jf1b0SHzUv
+KBds0pjBqAlkd25HN7rOrFleaJ1/ctaJxQZBKT5ZPt0m9STJEadao0xAH0ahmbWn
+OlFuhjuefXKnEgV4We0+UXgVCwOPjdAvBbI+e0ocS3MFEvzG6uBQE3xDk3SzynTn
+jh8BCNAw1FtxNrQHusEwMFxIt4I7mKZ9YIqioymCzLq9gwQbooMDQaHWBfEbwrbw
+qHyGO0aoSCqI3Haadr8faqU9GY/rOPNk3sgrDQoo//fb4hVC1CLQJ13hef4Y53CI
+rU7m2Ys6xt0nUW7/vGT1M0NPAgMBAAGjQjBAMA4GA1UdDwEB/wQEAwIBBjAPBgNV
+HRMBAf8EBTADAQH/MB0GA1UdDgQWBBR5tFnme7bl5AFzgAiIyBpY9umbbjANBgkq
+hkiG9w0BAQsFAAOCAgEAVR9YqbyyqFDQDLHYGmkgJykIrGF1XIpu+ILlaS/V9lZL
+ubhzEFnTIZd+50xx+7LSYK05qAvqFyFWhfFQDlnrzuBZ6brJFe+GnY+EgPbk6ZGQ
+3BebYhtF8GaV0nxvwuo77x/Py9auJ/GpsMiu/X1+mvoiBOv/2X/qkSsisRcOj/KK
+NFtY2PwByVS5uCbMiogziUwthDyC3+6WVwW6LLv3xLfHTjuCvjHIInNzktHCgKQ5
+ORAzI4JMPJ+GslWYHb4phowim57iaztXOoJwTdwJx4nLCgdNbOhdjsnvzqvHu7Ur
+TkXWStAmzOVyyghqpZXjFaH3pO3JLF+l+/+sKAIuvtd7u+Nxe5AW0wdeRlN8NwdC
+jNPElpzVmbUq4JUagEiuTDkHzsxHpFKVK7q4+63SM1N95R1NbdWhscdCb+ZAJzVc
+oyi3B43njTOQ5yOf+1CceWxG1bQVs5ZufpsMljq4Ui0/1lvh+wjChP4kqKOJ2qxq
+4RgqsahDYVvTH9w7jXbyLeiNdd8XM2w9U/t7y0Ff/9yi0GE44Za4rF2LN9d11TPA
+mRGunUHBcnWEvgJBQl9nJEiU0Zsnvgc/ubhPgXRR4Xq37Z0j4r7g1SgEEzwxA57d
+emyPxgcYxn/eR44/KJ4EBs+lVDR3veyJm+kXQ99b21/+jh5Xos1AnX5iItreGCc=
+-----END CERTIFICATE-----

README.md

@@ -1,12 +1,142 @@
----
-title: App
-emoji: 🏆
-colorFrom: blue
-colorTo: green
-sdk: gradio
-sdk_version: 5.38.1
-app_file: app.py
-pinned: false
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+---
+title: app
+app_file: app.py
+sdk: gradio
+sdk_version: 5.38.1
+---
+# 🚀 Photo Upscaler - Hugging Face Gradio App
+
+Pokročilá aplikace pro zvětšování fotografií pomocí AI modelů z Hugging Face.
+
+## ✨ Funkce
+
+- 🔍 **AI Upscaling**: Používá nejmodernější modely pro zvětšování obrázků
+- 🎯 **Více modelů**: Různé modely pro různé typy obrázků
+- 🌐 **Hugging Face integrace**: Přímé propojení s HF modely
+- 🎨 **Moderní UI**: Přehledné a intuitivní rozhraní
+- ⚡ **GPU podpora**: Automatická detekce CUDA
+
+## 🛠️ Instalace
+
+### 1. Klonování a příprava prostředí
+
+```bash
+# Přejděte do složky projektu
+cd gratio
+
+# Vytvořte virtuální prostředí
+python -m venv venv
+
+# Aktivace prostředí (Windows)
+venv\Scripts\activate
+
+# Aktivace prostředí (macOS/Linux)
+source venv/bin/activate
+```
+
+### 2. Instalace dependencies
+
+```bash
+pip install -r requirements.txt
+```
+
+### 3. Spuštění aplikace
+
+```bash
+python app.py
+```
+
+Aplikace se spustí na `http://localhost:7860`
+
+## 🎯 Jak používat
+
+1. **Nahrajte obrázek**: Přetáhněte nebo vyberte fotografii
+2. **Nastavte parametry**:
+   - Faktor zvětšení (1.5x - 4x)
+   - Vyberte vhodný model
+   - Volitelně zadejte HF token
+3. **Klikněte na "Zvětšit obrázek"**
+4. **Stáhněte výsledek**
+
+## 🤖 Dostupné modely
+
+- **microsoft/swin2SR-compressed-sr-x2-48**: Komprimovaný model pro 2x zvětšení
+- **microsoft/swin2SR-compressed-sr-x4-48**: Komprimovaný model pro 4x zvětšení
+- **caidas/swin2SR-realworld-sr-x4-64-bsrgan-psnr**: Nejlepší pro reálné fotografie
+- **microsoft/swin2SR-classical-sr-x2-64**: Pro umělé/digitální obrázky (2x)
+- **microsoft/swin2SR-classical-sr-x4-64**: Pro umělé/digitální obrázky (4x)
+
+## 🔐 Hugging Face Token
+
+Pro nejlepší výsledky doporučujeme:
+1. Registraci na [Hugging Face](https://huggingface.co/)
+2. Vytvoření tokenu v [nastavení](https://huggingface.co/settings/tokens)
+3. Zadání tokenu do aplikace
+
+## 💡 Tipy pro nejlepší výsledky
+
+- **Velikost obrázku**: 256x256 až 512x512 pixelů pro nejlepší rychlost
+- **Typ obrázku**: Volte model podle typu (reálné foto vs. digitální)
+- **GPU**: Pro rychlejší zpracování použijte GPU s CUDA
+- **Formát**: PNG poskytuje nejlepší kvalitu
+
+## 🚀 Nápady na rozšíření
+
+### Základní rozšíření:
+- **Batch processing**: Zpracování více obrázků najednou
+- **Noise reduction**: Odstraňování šumu z obrázků
+- **Format converter**: Konverze mezi různými formáty
+- **History**: Historie zpracovaných obrázků
+
+### Pokročilé funkce:
+- **Custom models**: Možnost nahrání vlastních modelů
+- **API endpoint**: RESTful API pro externí integrace
+- **Cloud storage**: Integrace s cloud úložišti
+- **Real-time preview**: Náhled během zpracování
+
+### AI vylepšení:
+- **Style transfer**: Přenos stylu na obrázky
+- **Colorization**: Obarvování černobílých fotek
+- **Face enhancement**: Specializované vylepšování obličejů
+- **HDR processing**: Zpracování HDR obrázků
+
+## 📊 Deployment na Hugging Face Spaces
+
+```bash
+# Přidejte do app.py na konec:
+if __name__ == "__main__":
+    demo.launch()
+
+# Vytvořte app.py s touto konfigurací pro HF Spaces
+```
+
+## 🔧 Troubleshooting
+
+### Časté problémy:
+
+**Model se nenačte**:
+- Zkontrolujte internetové připojení
+- Ověřte HF token
+- Zkuste jiný model
+
+**Pomalé zpracování**:
+- Zmenšete velikost obrázku
+- Použijte GPU
+- Vyberte komprimovaný model
+
+**Chyba paměti**:
+- Snižte rozlišení vstupního obrázku
+- Zavřete ostatní aplikace
+- Použijte menší model
+
+## 📝 Licence
+
+MIT License - můžete svobodně používat a upravovat.
+
+## 🤝 Přispívání
+
+Máte nápad na vylepšení? Vytvořte issue nebo pošlete pull request!
+
+---
+
+**Užijte si zvětšování svých fotografií! 📸✨** 

app.py

@@ -0,0 +1,240 @@
+import gradio as gr
+import torch
+from PIL import Image
+import numpy as np
+from transformers import pipeline
+import requests
+from io import BytesIO
+import os
+from huggingface_hub import login
+import warnings
+warnings.filterwarnings("ignore")
+
+class PhotoUpscaler:
+    def __init__(self):
+        self.device = "cuda" if torch.cuda.is_available() else "cpu"
+        self.current_model = None
+        self.upscaler = None
+        self.load_default_model()
+    
+    def load_default_model(self):
+        """Load default upscaling model"""
+        try:
+            # Using a Real-ESRGAN style model from Hugging Face
+            self.current_model = "caidas/swin2SR-realworld-sr-x4-64-bsrgan-psnr"
+            self.upscaler = pipeline(
+                "image-to-image",
+                model=self.current_model,
+                device=0 if self.device == "cuda" else -1
+            )
+            return f"✅ Model načten: {self.current_model}"
+        except Exception as e:
+            # Fallback to a simpler approach
+            self.current_model = "microsoft/swin2SR-compressed-sr-x2-48"
+            try:
+                self.upscaler = pipeline(
+                    "image-to-image", 
+                    model=self.current_model,
+                    device=0 if self.device == "cuda" else -1
+                )
+                return f"✅ Fallback model načten: {self.current_model}"
+            except:
+                return f"❌ Chyba při načítání modelů: {str(e)}"
+    
+    def upscale_image(self, image, scale_factor=2, model_choice="default"):
+        """Upscale image using selected model"""
+        if image is None:
+            return None, "❌ Žádný obrázek nebyl nahrán"
+        
+        try:
+            # Convert to PIL if needed
+            if isinstance(image, np.ndarray):
+                image = Image.fromarray(image)
+            
+            # Resize for processing if image is too large
+            max_size = 1024
+            if max(image.size) > max_size:
+                ratio = max_size / max(image.size)
+                new_size = tuple(int(dim * ratio) for dim in image.size)
+                image = image.resize(new_size, Image.Resampling.LANCZOS)
+            
+            # Change model if requested
+            if model_choice != "default" and model_choice != self.current_model:
+                self.load_model(model_choice)
+            
+            # Perform upscaling
+            if self.upscaler:
+                # For pipeline-based upscaling
+                upscaled = self.upscaler(image)
+                if isinstance(upscaled, list):
+                    upscaled = upscaled[0]
+                if hasattr(upscaled, 'images'):
+                    upscaled = upscaled.images[0]
+                elif isinstance(upscaled, dict) and 'image' in upscaled:
+                    upscaled = upscaled['image']
+                
+                return upscaled, f"✅ Obrázek zvětšen pomocí {self.current_model}"
+            else:
+                # Simple fallback upscaling
+                new_size = tuple(int(dim * scale_factor) for dim in image.size)
+                upscaled = image.resize(new_size, Image.Resampling.LANCZOS)
+                return upscaled, f"✅ Obrázek zvětšen pomocí klasického algoritmu (fallback)"
+                
+        except Exception as e:
+            return None, f"❌ Chyba při zpracování: {str(e)}"
+    
+    def load_model(self, model_name):
+        """Load specific model"""
+        try:
+            self.current_model = model_name
+            self.upscaler = pipeline(
+                "image-to-image",
+                model=model_name,
+                device=0 if self.device == "cuda" else -1
+            )
+            return f"✅ Model změněn na: {model_name}"
+        except Exception as e:
+            return f"❌ Chyba při načítání modelu {model_name}: {str(e)}"
+
+# Initialize upscaler
+upscaler = PhotoUpscaler()
+
+# Available models for upscaling
+UPSCALING_MODELS = [
+    "default",
+    "microsoft/swin2SR-compressed-sr-x2-48",
+    "microsoft/swin2SR-compressed-sr-x4-48", 
+    "caidas/swin2SR-realworld-sr-x4-64-bsrgan-psnr",
+    "microsoft/swin2SR-classical-sr-x2-64",
+    "microsoft/swin2SR-classical-sr-x4-64"
+]
+
+def process_upscaling(image, scale_factor, model_choice, hf_token):
+    """Main processing function"""
+    # Login to HuggingFace if token provided
+    if hf_token and hf_token.strip():
+        try:
+            login(hf_token)
+            status_msg = "🔐 Přihlášen k Hugging Face | "
+        except:
+            status_msg = "⚠️ Problém s HF tokenem | "
+    else:
+        status_msg = "ℹ️ Používám veřejné modely | "
+    
+    # Perform upscaling
+    result_image, process_msg = upscaler.upscale_image(image, scale_factor, model_choice)
+    
+    return result_image, status_msg + process_msg
+
+def get_model_info():
+    """Get current model information"""
+    device_info = f"Zařízení: {upscaler.device.upper()}"
+    model_info = f"Aktuální model: {upscaler.current_model}"
+    return f"ℹ️ {device_info} | {model_info}"
+
+# Create Gradio interface
+with gr.Blocks(
+    title="🚀 Photo Upscaler - Hugging Face",
+    theme=gr.themes.Soft(),
+    css="""
+    .gradio-container {
+        max-width: 1200px !important;
+        margin: auto !important;
+    }
+    .title {
+        text-align: center;
+        color: #ff6b35;
+        margin-bottom: 20px;
+    }
+    """
+) as demo:
+    
+    gr.HTML("""
+    <div class="title">
+        <h1>🚀 Photo Upscaler s Hugging Face</h1>
+        <p>Zvětšujte své fotografie pomocí pokročilých AI modelů</p>
+    </div>
+    """)
+    
+    with gr.Row():
+        with gr.Column(scale=1):
+            gr.Markdown("### 📤 Vstup")
+            input_image = gr.Image(
+                label="Nahrajte fotografii",
+                type="pil",
+                format="png"
+            )
+            
+            scale_factor = gr.Slider(
+                minimum=1.5,
+                maximum=4.0,
+                value=2.0,
+                step=0.5,
+                label="Faktor zvětšení",
+                info="Kolikrát zvětšit obrázek"
+            )
+            
+            model_choice = gr.Dropdown(
+                choices=UPSCALING_MODELS,
+                value="default",
+                label="Vyberte model",
+                info="Různé modely pro různé typy obrázků"
+            )
+            
+            hf_token = gr.Textbox(
+                label="Hugging Face Token (volitelné)",
+                placeholder="hf_xxxxxxxxxxxxx",
+                type="password",
+                info="Pro přístup k privátním modelům"
+            )
+            
+            upscale_btn = gr.Button(
+                "🔍 Zvětšit obrázek",
+                variant="primary",
+                size="lg"
+            )
+            
+        with gr.Column(scale=1):
+            gr.Markdown("### 📥 Výstup")
+            output_image = gr.Image(
+                label="Zvětšený obrázek",
+                type="pil"
+            )
+            
+            status_text = gr.Textbox(
+                label="Status",
+                interactive=False,
+                max_lines=3
+            )
+            
+            info_btn = gr.Button("ℹ️ Info o modelu")
+    
+    # Event handlers
+    upscale_btn.click(
+        fn=process_upscaling,
+        inputs=[input_image, scale_factor, model_choice, hf_token],
+        outputs=[output_image, status_text]
+    )
+    
+    info_btn.click(
+        fn=get_model_info,
+        outputs=status_text
+    )
+    
+    # Examples
+    gr.Markdown("### 📋 Tipy pro použití")
+    gr.Markdown("""
+    - **Nejlepší výsledky**: Používejte obrázky s rozlišením 256x256 až 512x512 pixelů
+    - **Modely**: Různé modely jsou optimalizované pro různé typy obrázků
+    - **Real-world modely**: Nejlepší pro fotografie z reálného světa
+    - **Classical modely**: Vhodné pro umělé nebo digitální obrázky
+    - **HF Token**: Zadejte pro přístup k nejnovějším modelům
+    """)
+
+if __name__ == "__main__":
+    demo.launch(
+        share=True,
+        server_name="0.0.0.0",
+        server_port=7860,
+        show_error=True
+    ) 

app_hf_spaces.py

@@ -0,0 +1,143 @@
+import gradio as gr
+import torch
+from PIL import Image
+import numpy as np
+from transformers import pipeline
+import os
+from huggingface_hub import login
+import warnings
+warnings.filterwarnings("ignore")
+
+class PhotoUpscaler:
+    def __init__(self):
+        self.device = "cuda" if torch.cuda.is_available() else "cpu"
+        self.current_model = "microsoft/swin2SR-compressed-sr-x2-48"
+        self.upscaler = None
+        self.load_default_model()
+    
+    def load_default_model(self):
+        """Load default upscaling model optimized for HF Spaces"""
+        try:
+            self.upscaler = pipeline(
+                "image-to-image",
+                model=self.current_model,
+                device=0 if self.device == "cuda" else -1
+            )
+            return f"✅ Model loaded: {self.current_model}"
+        except Exception as e:
+            return f"❌ Error loading model: {str(e)}"
+    
+    def upscale_image(self, image, scale_factor=2):
+        """Upscale image with simplified processing for HF Spaces"""
+        if image is None:
+            return None, "❌ No image uploaded"
+        
+        try:
+            # Convert to PIL if needed
+            if isinstance(image, np.ndarray):
+                image = Image.fromarray(image)
+            
+            # Limit size for HF Spaces (smaller memory limits)
+            max_size = 512
+            if max(image.size) > max_size:
+                ratio = max_size / max(image.size)
+                new_size = tuple(int(dim * ratio) for dim in image.size)
+                image = image.resize(new_size, Image.Resampling.LANCZOS)
+            
+            # Perform upscaling
+            if self.upscaler:
+                try:
+                    upscaled = self.upscaler(image)
+                    if isinstance(upscaled, list):
+                        upscaled = upscaled[0]
+                    return upscaled, f"✅ Image upscaled using {self.current_model}"
+                except:
+                    # Fallback to simple upscaling if model fails
+                    new_size = tuple(int(dim * scale_factor) for dim in image.size)
+                    upscaled = image.resize(new_size, Image.Resampling.LANCZOS)
+                    return upscaled, "✅ Image upscaled using fallback method"
+            else:
+                new_size = tuple(int(dim * scale_factor) for dim in image.size)
+                upscaled = image.resize(new_size, Image.Resampling.LANCZOS)
+                return upscaled, "✅ Image upscaled using classic algorithm"
+                
+        except Exception as e:
+            return None, f"❌ Processing error: {str(e)}"
+
+# Initialize upscaler
+upscaler = PhotoUpscaler()
+
+def process_upscaling(image, scale_factor):
+    """Main processing function for HF Spaces"""
+    result_image, process_msg = upscaler.upscale_image(image, scale_factor)
+    return result_image, process_msg
+
+# Create Gradio interface optimized for HF Spaces
+with gr.Blocks(
+    title="🚀 Photo Upscaler",
+    theme=gr.themes.Default(),
+    css="""
+    .gradio-container {
+        max-width: 900px !important;
+        margin: auto !important;
+    }
+    """
+) as demo:
+    
+    gr.HTML("""
+    <div style="text-align: center; margin-bottom: 20px;">
+        <h1>🚀 Photo Upscaler</h1>
+        <p>Enhance your photos with AI-powered upscaling</p>
+    </div>
+    """)
+    
+    with gr.Row():
+        with gr.Column():
+            gr.Markdown("### 📤 Input")
+            input_image = gr.Image(
+                label="Upload Photo",
+                type="pil"
+            )
+            
+            scale_factor = gr.Slider(
+                minimum=1.5,
+                maximum=3.0,
+                value=2.0,
+                step=0.5,
+                label="Scale Factor"
+            )
+            
+            upscale_btn = gr.Button(
+                "🔍 Upscale Image",
+                variant="primary"
+            )
+            
+        with gr.Column():
+            gr.Markdown("### 📥 Output")
+            output_image = gr.Image(
+                label="Upscaled Image"
+            )
+            
+            status_text = gr.Textbox(
+                label="Status",
+                interactive=False
+            )
+    
+    # Event handler
+    upscale_btn.click(
+        fn=process_upscaling,
+        inputs=[input_image, scale_factor],
+        outputs=[output_image, status_text]
+    )
+    
+    # Tips
+    gr.Markdown("""
+    ### 💡 Tips for best results:
+    - Use images between 256x256 and 512x512 pixels
+    - PNG format provides best quality
+    - Lower scale factors work faster
+    """)
+
+# Launch for HF Spaces
+if __name__ == "__main__":
+    demo.launch() 

requirements.txt

@@ -0,0 +1,11 @@
+gradio>=4.0.0
+torch>=2.0.0
+torchvision>=0.15.0
+transformers>=4.35.0
+huggingface-hub>=0.17.0
+Pillow>=9.0.0
+numpy>=1.21.0
+requests>=2.28.0
+accelerate>=0.20.0
+diffusers>=0.21.0
+opencv-python>=4.7.0