Upload 7 files

README.md

@@ -1,13 +1,72 @@
 ---
-title: Dino Analyzer
-emoji: 📊
-colorFrom: pink
-colorTo: indigo
-sdk: gradio
-sdk_version: 5.31.0
+title: DINO - Dinosaur Analyzer
+emoji: 🦕
+colorFrom: green
+colorTo: gray
+sdk: streamlit
+sdk_version: 1.45.1
 app_file: app.py
 pinned: false
 license: mit
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# 🦕 DINO - Dinosaur Image Neural Observer
+
+An innovative **Image ORM** project that uses **Gemini API** to analyze plastic dinosaur figurines and extract structured information including species identification, color analysis, geological periods, and educational facts.
+
+## 🚀 Try it Live!
+
+Upload a photo of your dinosaur figurine and get instant analysis with:
+- 🔍 **Species identification** - Scientific name and classification
+- 🎨 **Color analysis** - Description of the figurine's colors
+- ⏰ **Geological period** - When this dinosaur lived
+- 📚 **Educational facts** - Interesting information about the species
+
+## 🔑 API Key Required
+
+This app requires a **Gemini API key** to function. You can:
+1. Get your free API key at [Google AI Studio](https://ai.google.dev/)
+2. Enter it in the sidebar when using the app
+
+## 🛠️ Technology Stack
+
+- **AI Model**: Google Gemini API for image analysis
+- **Framework**: Streamlit for web interface
+- **Language**: Python with Pydantic for data validation
+- **Image Processing**: PIL/Pillow for image optimization
+
+## 📊 Features
+
+- ✅ **Real-time analysis** of dinosaur figurines
+- ✅ **Structured JSON output** with consistent data format
+- ✅ **Russian language support** for AI responses
+- ✅ **Modern web interface** with drag-and-drop upload
+- ✅ **Export functionality** for analysis results
+- ✅ **Error handling** and validation
+
+## 🔗 Source Code
+
+Full source code, documentation, and local setup instructions available on GitHub:
+[https://github.com/trashchenkov/dino](https://github.com/trashchenkov/dino)
+
+## 📝 Example Output
+
+```json
+{
+  "species_name": "Тираннозавр Рекс",
+  "color_description": "зеленый с коричневыми полосами",
+  "geological_period": "Поздний меловой период",
+  "brief_info": "Один из крупнейших наземных хищников всех времен"
+}
+```
+
+## 💡 Tips for Best Results
+
+- Use clear, well-lit photos
+- Ensure the dinosaur figurine is clearly visible
+- Avoid strong shadows or reflections
+- Supported formats: PNG, JPG, JPEG
+
+---
+
+**Made with ❤️ for dinosaur enthusiasts and AI technology lovers!** 

app.py

@@ -0,0 +1,245 @@
+import streamlit as st
+import os
+from PIL import Image
+from dino_analyzer import DinosaurAnalyzer
+from models import DinosaurInfo
+from utils import format_file_size
+
+def main():
+    """Основная функция веб-приложения для Hugging Face Spaces."""
+    
+    # Настройка страницы
+    st.set_page_config(
+        page_title="🦕 DINO - Анализатор динозавров",
+        page_icon="🦕",
+        layout="wide",
+        initial_sidebar_state="expanded"
+    )
+    
+    # Заголовок
+    st.title("🦕 DINO - Анализатор динозавров")
+    st.markdown("### Загрузите фотографию фигурки динозавра и получите подробную информацию!")
+    
+    # Информация о проекте в верхней части
+    with st.expander("ℹ️ О проекте DINO", expanded=False):
+        st.markdown("""
+        **DINO (Dinosaur Image Neural Observer)** - это инновационный проект, демонстрирующий концепцию "Image ORM" 
+        с использованием Gemini API.
+        
+        **Возможности:**
+        - 🔍 **Идентификация вида динозавра** по изображению фигурки
+        - 🎨 **Анализ цветов** пластиковой фигурки
+        - ⏰ **Геологический период** обитания динозавра
+        - 📚 **Интересные факты** о виде
+        
+        **🔗 Исходный код:** [GitHub Repository](https://github.com/trashchenkov/dino)
+        """)
+    
+    # Боковая панель с настройками
+    with st.sidebar:
+        st.header("⚙️ Настройки")
+        
+        # Проверяем наличие API ключа в секретах HF
+        api_key = st.secrets.get("GEMINI_API_KEY", None)
+        
+        if api_key:
+            st.success("✅ API ключ настроен администратором")
+            st.info("💡 Вы можете сразу использовать приложение!")
+        else:
+            st.warning("⚠️ API ключ не настроен")
+            # Ввод API ключа
+            api_key = st.text_input(
+                "🔑 Введите ваш Gemini API Key:",
+                type="password",
+                placeholder="Введите ваш API ключ здесь...",
+                help="Получите API ключ на https://ai.google.dev/"
+            )
+            
+            if not api_key:
+                st.error("❌ Для работы приложения необходим API ключ Gemini")
+                st.markdown("""
+                **Как получить API ключ:**
+                1. Перейдите на [Google AI Studio](https://ai.google.dev/)
+                2. Войдите в аккаунт Google
+                3. Создайте новый API ключ
+                4. Введите его в поле выше
+                """)
+        
+        st.markdown("---")
+        
+        # Информация о проекте
+        st.markdown("""
+        **Советы для лучших результатов:**
+        - Используйте четкие фотографии
+        - Хорошее освещение важно
+        - Фигурка должна быть хорошо видна
+        - Избегайте сильных теней
+        
+        **Поддерживаемые форматы:**
+        - PNG, JPG, JPEG
+        - Максимум 200MB
+        """)
+    
+    # Основная область
+    if api_key:
+        col1, col2 = st.columns([1, 1])
+        
+        with col1:
+            st.header("📸 Загрузка изображения")
+            
+            uploaded_file = st.file_uploader(
+                "Выберите изображение фигурки динозавра",
+                type=['png', 'jpg', 'jpeg'],
+                help="Поддерживаемые форматы: PNG, JPG, JPEG"
+            )
+            
+            if uploaded_file is not None:
+                # Отображение загруженного изображения
+                image = Image.open(uploaded_file)
+                st.image(image, caption="Загруженное изображение", use_container_width=True)
+                
+                # Информация о файле
+                file_size = len(uploaded_file.getvalue())
+                st.info(f"📁 Размер файла: {format_file_size(file_size)}")
+                st.info(f"📐 Размеры: {image.width} × {image.height} пикселей")
+                
+                # Кнопка анализа
+                if st.button("🔍 Анализировать динозавра", type="primary", use_container_width=True):
+                    analyze_dinosaur(image, api_key, col2)
+        
+        with col2:
+            st.header("📊 Результаты анализа")
+            st.info("👆 Загрузите изображение и нажмите 'Анализировать' для получения результатов")
+    else:
+        st.warning("⚠️ Для использования приложения необходим API ключ Gemini")
+
+
+def analyze_dinosaur(image: Image.Image, api_key: str, result_column):
+    """
+    Анализирует изображение динозавра и отображает результаты.
+    
+    Args:
+        image: PIL изображение
+        api_key: API ключ для Gemini
+        result_column: Столбец Streamlit для отображения результатов
+    """
+    with result_column:
+        # Индикатор загрузки
+        with st.spinner("🔍 Анализируем динозавра..."):
+            try:
+                # Создаем анализатор и анализируем изображение
+                analyzer = DinosaurAnalyzer(api_key=api_key)
+                result = analyzer.analyze_image_from_pil(image)
+                
+                if result:
+                    display_results(result)
+                else:
+                    st.error("❌ Не удалось проанализировать изображение")
+                    st.info("💡 Попробуйте другое изображение или проверьте качество фото")
+                    
+            except ValueError as e:
+                st.error(f"❌ Ошибка конфигурации: {e}")
+                st.info("💡 Убедитесь, что API ключ корректный")
+            except Exception as e:
+                st.error(f"❌ Произошла ошибка: {e}")
+                st.info("💡 Попробуйте еще раз или проверьте подключение к интернету")
+
+
+def display_results(info: DinosaurInfo):
+    """
+    Отображает результаты анализа в читаемом формате.
+    
+    Args:
+        info: Информация о динозавре
+    """
+    # Основная информация
+    st.success("✅ Анализ завершен!")
+    
+    # Используем более читаемый способ отображения данных
+    st.subheader("📛 Вид динозавра")
+    st.write(f"**{info.species_name}**")
+    
+    st.subheader("🎨 Цвет фигурки")
+    st.write(f"{info.color_description}")
+    
+    st.subheader("⏰ Геологический период")
+    st.write(f"{info.geological_period}")
+    
+    # Интересный факт в отдельном блоке
+    st.subheader("📚 Интересный факт")
+    st.info(info.brief_info)
+    
+    # Дополнительные действия
+    st.markdown("---")
+    st.subheader("💾 Экспорт данных")
+    
+    col_actions1, col_actions2 = st.columns(2)
+    
+    with col_actions1:
+        if st.button("📋 Показать текстовые данные", use_container_width=True):
+            data_text = f"""Вид: {info.species_name}
+Цвет фигурки: {info.color_description}
+Период: {info.geological_period}
+Интересный факт: {info.brief_info}"""
+            st.text_area("Данные для копирования:", data_text, height=150)
+    
+    with col_actions2:
+        json_data = info.model_dump_json(indent=2)
+        st.download_button(
+            label="💾 Скачать JSON",
+            data=json_data,
+            file_name="dinosaur_info.json",
+            mime="application/json",
+            use_container_width=True
+        )
+    
+    # JSON данные (сворачиваемые)
+    with st.expander("🔧 Детальные данные (JSON)"):
+        st.json(info.model_dump())
+
+
+# Футер
+def show_footer():
+    """Отображает футер с дополнительной информацией."""
+    st.markdown("---")
+    
+    # Статистика и дополнительная информация
+    col1, col2, col3 = st.columns(3)
+    
+    with col1:
+        st.markdown("""
+        **🔬 Технологии:**
+        - Gemini AI API
+        - Streamlit
+        - Python
+        - Pydantic
+        """)
+    
+    with col2:
+        st.markdown("""
+        **📊 Возможности:**
+        - Распознавание видов
+        - Анализ цветов
+        - Исторические данные
+        - Образовательные факты
+        """)
+    
+    with col3:
+        st.markdown("""
+        **🚀 Ссылки:**
+        - [GitHub](https://github.com/trashchenkov/dino)
+        - [Документация](https://github.com/trashchenkov/dino#readme)
+        - [Gemini API](https://ai.google.dev/)
+        """)
+    
+    st.markdown("""
+    <div style='text-align: center; margin-top: 2rem;'>
+        <p>🦕 <strong>DINO Project</strong> - Image ORM для анализа динозавров</p>
+        <p>Powered by <strong>Gemini API</strong> • Deployed on <strong>Hugging Face Spaces</strong> 🚀</p>
+    </div>
+    """, unsafe_allow_html=True)
+
+
+if __name__ == "__main__":
+    main()
+    show_footer() 

dino_analyzer.py

@@ -0,0 +1,202 @@
+import os
+import json
+from typing import Optional
+from PIL import Image
+import google.generativeai as genai
+
+# Пытаемся импортировать dotenv, если доступен (для локальной разработки)
+try:
+    from dotenv import load_dotenv
+    load_dotenv()
+except ImportError:
+    # На HF Spaces dotenv может быть недоступен, это нормально
+    pass
+
+from models import DinosaurInfo
+from utils import optimize_image_for_api, save_temp_image, cleanup_temp_file, validate_image_file
+
+class DinosaurAnalyzer:
+    """Класс для анализа изображений динозавров с помощью Gemini API."""
+    
+    def __init__(self, api_key: Optional[str] = None):
+        """
+        Инициализация анализатора.
+        
+        Args:
+            api_key: API ключ для Gemini. Если не указан, будет взят из переменной окружения.
+        """
+        if api_key is None:
+            api_key = os.getenv('GEMINI_API_KEY')
+            
+        if not api_key:
+            raise ValueError(
+                "API ключ не найден. Укажите его в параметре api_key или "
+                "установите переменную окружения GEMINI_API_KEY"
+            )
+            
+        genai.configure(api_key=api_key)
+        
+        # Инициализация модели с системной инструкцией
+        self.model = genai.GenerativeModel(
+            model_name='gemini-1.5-flash-latest',
+            generation_config={
+                "response_mime_type": "application/json",
+                "response_schema": DinosaurInfo
+            },
+            system_instruction="""
+            ВАЖНО: Отвечай ТОЛЬКО на РУССКОМ языке! Весь твой ответ должен быть на русском языке.
+            
+            Ты — эксперт-палеонтолог и ИИ для анализа изображений пластиковых фигурок динозавров. 
+            Твоя задача — идентифицировать вид динозавра по фотографии игрушечной фигурки.
+            
+            ИНСТРУКЦИИ ПО АНАЛИЗУ:
+            1. 🔍 ОПРЕДЕЛИ ВИД: Внимательно изучи форму тела, голову, конечности, хвост, характерные особенности для определения точного вида динозавра. Назови вид на РУССКОМ языке.
+            
+            2. 🎨 ОПИШИ ЦВЕТА: Опиши основные цвета именно этой пластиковой фигурки (как они выглядят на фото). НЕ описывай реальные цвета динозавра, а только то, что видишь на игрушке.
+            
+            3. ⏰ УКАЖИ ПЕРИОД: Определи геологический период, в котором жил этот вид динозавра. Ответ дай на РУССКОМ языке (например, "Юрский период", "Поздний меловой период").
+            
+            4. 📚 РАССКАЖИ ФАКТ: Поделись интересным фактом об этом виде динозавра. Факт должен быть познавательным и написан на РУССКОМ языке.
+            
+            ВАЖНЫЕ ТРЕБОВАНИЯ:
+            - ВСЕ поля заполняй только на РУССКОМ языке
+            - Если не можешь точно определить вид, напиши "Неопределенный вид" или опиши как "Динозавр семейства..."
+            - Для цветов используй простые русские названия (зеленый, коричневый, желтый и т.д.)
+            - Геологические периоды называй по-русски
+            - Факты должны быть интересными и понятными
+            
+            Верни всю информацию в указанной JSON-схеме НА РУССКОМ ЯЗЫКЕ.
+            """
+        )
+    
+    def analyze_image(self, image_path: str) -> Optional[DinosaurInfo]:
+        """
+        Анализирует изображение динозавра и возвращает структурированную информацию.
+        
+        Args:
+            image_path: Путь к файлу изображения
+            
+        Returns:
+            DinosaurInfo объект с информацией о динозавре или None при ошибке
+        """
+        try:
+            # Проверяе�� существование и валидность файла
+            if not os.path.exists(image_path):
+                print(f"Ошибка: файл {image_path} не найден")
+                return None
+                
+            if not validate_image_file(image_path):
+                print(f"Ошибка: файл {image_path} не является корректным изображением")
+                return None
+            
+            # Загружаем и оптимизируем изображение
+            img = Image.open(image_path)
+            optimized_img = optimize_image_for_api(img)
+            
+            # Отправляем запрос к Gemini API
+            response = self.model.generate_content([optimized_img])
+            
+            # Парсим JSON ответ в объект DinosaurInfo
+            dino_data = DinosaurInfo.model_validate_json(response.text)
+            return dino_data
+            
+        except json.JSONDecodeError as e:
+            print(f"Ошибка парсинга JSON: {e}")
+            print(f"Ответ модели: {response.text}")
+            return None
+        except Exception as e:
+            print(f"Произошла ошибка при анализе изображения: {e}")
+            if 'response' in locals() and hasattr(response, 'prompt_feedback'):
+                print(f"Обратная связь: {response.prompt_feedback}")
+            return None
+    
+    def analyze_image_from_pil(self, image: Image.Image) -> Optional[DinosaurInfo]:
+        """
+        Анализирует изображение динозавра из PIL.Image объекта.
+        
+        Args:
+            image: PIL.Image объект
+            
+        Returns:
+            DinosaurInfo объект с информацией о динозавре или None при ошибке
+        """
+        try:
+            print(f"📸 Анализируем изображение размера {image.size}...")
+            
+            # Оптимизируем изображение для API
+            optimized_image = optimize_image_for_api(image)
+            print(f"✅ Изображение оптимизировано до размера {optimized_image.size}")
+            
+            # Отправляем запрос к Gemini API
+            response = self.model.generate_content([
+                "Проанализируй эту фигурку динозавра согласно инструкциям:",
+                optimized_image
+            ])
+            
+            # Парсим JSON ответ
+            result_text = response.text.strip()
+            print(f"📝 Получен ответ от API: {result_text[:100]}...")
+            
+            # Парсим ответ как JSON и создаем объект DinosaurInfo
+            result_data = json.loads(result_text)
+            dinosaur_info = DinosaurInfo(**result_data)
+            
+            print(f"🦕 Успешно идентифицирован: {dinosaur_info.species_name}")
+            return dinosaur_info
+            
+        except json.JSONDecodeError as e:
+            print(f"❌ Ошибка парсинга JSON: {e}")
+            print(f"📄 Полученный ответ: {result_text}")
+            return None
+        except Exception as e:
+            print(f"❌ Ошибка при анализе изображения: {e}")
+            return None
+    
+    def print_dinosaur_info(self, info: DinosaurInfo) -> None:
+        """
+        Красиво выводит информацию о динозавре.
+        
+        Args:
+            info: Объект с информацией о динозавре
+        """
+        separator = "=" * 50
+        print(f"\n{separator}")
+        print("🦕 ИНФОРМАЦИЯ О ДИНОЗАВРЕ 🦕")
+        print(f"{separator}")
+        print(f"📛 Вид: {info.species_name}")
+        print(f"🎨 Цвет фигурки: {info.color_description}")
+        print(f"⏰ Период: {info.geological_period}")
+        print(f"📚 Интересный факт: {info.brief_info}")
+        print(f"{separator}\n")
+
+
+def main():
+    """Основная функция для демонстрации работы анализатора."""
+    # Пример использования
+    try:
+        analyzer = DinosaurAnalyzer()
+        
+        # Замените на путь к вашему изображению динозавра
+        image_path = input("Введите путь к изображению динозавра: ").strip()
+        
+        if not image_path:
+            print("Путь к изображению не указан")
+            return
+        
+        print("🔍 Анализируем изображение...")
+        info = analyzer.analyze_image(image_path)
+        
+        if info:
+            analyzer.print_dinosaur_info(info)
+        else:
+            print("❌ Не удалось проанализировать изображение")
+            
+    except ValueError as e:
+        print(f"❌ Ошибка конфигурации: {e}")
+        print("💡 Убедитесь, что у вас есть API ключ для Gemini")
+    except Exception as e:
+        print(f"❌ Неожиданная ошибка: {e}")
+
+
+if __name__ == "__main__":
+    main() 

models.py

@@ -0,0 +1,19 @@
+from pydantic import BaseModel, Field
+from typing import Optional
+
+
+class DinosaurInfo(BaseModel):
+    """Модель для структурированной информации о динозавре."""
+    
+    species_name: str = Field(
+        description="Научное или общепринятое название вида динозавра"
+    )
+    color_description: str = Field(
+        description="Описание основных цветов фигурки динозавра"
+    )
+    geological_period: str = Field(
+        description="Геологический период, в котором обитал этот вид динозавра (например, Юрский, Меловой)"
+    )
+    brief_info: str = Field(
+        description="Краткая интересная информация о динозавре (1-2 предложения)"
+    ) 

requirements.txt

@@ -0,0 +1,6 @@
+google-generativeai>=0.8.0
+Pillow>=10.0.0
+pydantic>=2.5.0
+python-dotenv>=1.0.0
+streamlit>=1.28.0
+requests>=2.31.0 

utils.py

@@ -0,0 +1,180 @@
+import os
+from typing import Tuple, Optional
+from PIL import Image, ImageOps
+import io
+
+
+def validate_image_file(file_path: str) -> bool:
+    """
+    Проверяет, является ли файл корректным изображением.
+    
+    Args:
+        file_path: Путь к файлу изображения
+        
+    Returns:
+        True если файл является корректным изображением
+    """
+    try:
+        with Image.open(file_path) as img:
+            img.verify()
+        return True
+    except Exception:
+        return False
+
+
+def get_image_info(file_path: str) -> Optional[dict]:
+    """
+    Получает информацию об изображении.
+    
+    Args:
+        file_path: Путь к файлу изображения
+        
+    Returns:
+        Словарь с информацией об изображении или None при ошибке
+    """
+    try:
+        with Image.open(file_path) as img:
+            return {
+                "width": img.width,
+                "height": img.height,
+                "format": img.format,
+                "mode": img.mode,
+                "size_bytes": os.path.getsize(file_path)
+            }
+    except Exception:
+        return None
+
+
+def resize_image_if_needed(image: Image.Image, max_size: Tuple[int, int] = (1024, 1024)) -> Image.Image:
+    """
+    Изменяет размер изображения, если оно слишком большое.
+    
+    Args:
+        image: PIL изображение
+        max_size: Максимальный размер (ширина, высота)
+        
+    Returns:
+        Изображение с измененным размером (если необходимо)
+    """
+    if image.width > max_size[0] or image.height > max_size[1]:
+        # Сохраняем пропорции
+        image.thumbnail(max_size, Image.Resampling.LANCZOS)
+    return image
+
+
+def optimize_image_for_api(image: Image.Image, quality: int = 85) -> Image.Image:
+    """
+    Оптимизирует изображение для отправки в API.
+    
+    Args:
+        image: PIL изображение
+        quality: Качество сжатия JPEG (1-100)
+        
+    Returns:
+        Оптимизированное изображение
+    """
+    # Изменяем размер если нужно
+    optimized = resize_image_if_needed(image)
+    
+    # Автоматически поворачиваем на основе EXIF данных
+    optimized = ImageOps.exif_transpose(optimized)
+    
+    # Конвертируем в RGB если изображение в RGBA или другом формате
+    if optimized.mode in ('RGBA', 'LA', 'P'):
+        # Создаем белый фон для прозрачных изображений
+        background = Image.new('RGB', optimized.size, (255, 255, 255))
+        if optimized.mode == 'P':
+            optimized = optimized.convert('RGBA')
+        background.paste(optimized, mask=optimized.split()[-1] if optimized.mode == 'RGBA' else None)
+        optimized = background
+    elif optimized.mode != 'RGB':
+        optimized = optimized.convert('RGB')
+    
+    return optimized
+
+
+def save_temp_image(image: Image.Image, prefix: str = "temp_dino") -> str:
+    """
+    Сохраняет временное изображение и возвращает путь к нему.
+    
+    Args:
+        image: PIL изображение
+        prefix: Префикс для имени файла
+        
+    Returns:
+        Путь к временному файлу
+    """
+    import tempfile
+    import uuid
+    
+    # Создаем уникальное имя файла
+    temp_name = f"{prefix}_{uuid.uuid4().hex[:8]}.jpg"
+    temp_path = os.path.join(tempfile.gettempdir(), temp_name)
+    
+    # Оптимизируем и сохраняем
+    optimized_image = optimize_image_for_api(image)
+    optimized_image.save(temp_path, "JPEG", quality=85, optimize=True)
+    
+    return temp_path
+
+
+def cleanup_temp_file(file_path: str) -> bool:
+    """
+    Удаляет временный файл.
+    
+    Args:
+        file_path: Путь к файлу для удаления
+        
+    Returns:
+        True если файл успешно удален
+    """
+    try:
+        if os.path.exists(file_path):
+            os.remove(file_path)
+            return True
+        return False
+    except Exception:
+        return False
+
+
+def convert_bytes_to_image(image_bytes: bytes) -> Optional[Image.Image]:
+    """
+    Конвертирует байты в PIL изображение.
+    
+    Args:
+        image_bytes: Байты изображения
+        
+    Returns:
+        PIL изображение или None при ошибке
+    """
+    try:
+        return Image.open(io.BytesIO(image_bytes))
+    except Exception:
+        return None
+
+
+def get_supported_formats() -> list:
+    """
+    Возвращает список поддерживаемых форматов изображений.
+    
+    Returns:
+        Список расширений файлов
+    """
+    return ['.jpg', '.jpeg', '.png', '.bmp', '.gif', '.tiff', '.webp']
+
+
+def format_file_size(size_bytes: int) -> str:
+    """
+    Форматирует размер файла в читаемый вид.
+    
+    Args:
+        size_bytes: Размер в байтах
+        
+    Returns:
+        Отформатированная строка размера
+    """
+    for unit in ['B', 'KB', 'MB', 'GB']:
+        if size_bytes < 1024.0:
+            return f"{size_bytes:.1f} {unit}"
+        size_bytes /= 1024.0
+    return f"{size_bytes:.1f} TB"