Реализация для дева с хот релоадом

.gitignore

@@ -1,13 +1,8 @@
-data/
-# Byte-compiled / optimized / DLL files
+# Python
 __pycache__/
 *.py[cod]
 *$py.class
-
-# C extensions
 *.so
-
-# Distribution / packaging
 .Python
 build/
 develop-eggs/
@@ -20,26 +15,82 @@ lib64/
 parts/
 sdist/
 var/
+wheels/
+share/python-wheels/
 *.egg-info/
 .installed.cfg
 *.egg
+MANIFEST
 
-# Installer logs
-pip-log.txt
-pip-delete-this-directory.txt
+# Virtual environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
 
-# Unit test / coverage reports
-htmlcov/
-.tox/
-.nox/
-.coverage
-.coverage.*
-.cache
-nosetests.xml
-coverage.xml
-*.cover
-.hypothesis/
+# IDE
+.vscode/
+.idea/
+*.swp
+*.swo
+*~
+
+# OS
+.DS_Store
+.DS_Store?
+._*
+.Spotlight-V100
+.Trashes
+ehthumbs.db
+Thumbs.db
+Desktop.ini
+
+# Logs
+*.log
+logs/
+log/
+
+# MinIO data and cache
+minio_data/
+.minio.sys/
+*.meta
+part.*
+
+# Docker
+.dockerignore
+docker-compose.override.yml
+
+# Environment variables
+.env
+.env.local
+.env.development.local
+.env.test.local
+.env.production.local
+
+# Temporary files
+*.tmp
+*.temp
+*.bak
+*.backup
+*.orig
+
+# Data files (Excel, CSV, etc.)
+*.xlsx
+*.xls
+*.xlsm
+*.csv
+*.json
+data/
+uploads/
+
+# Cache directories
+.cache/
 .pytest_cache/
+.coverage
+htmlcov/
 
 # Jupyter Notebook
 .ipynb_checkpoints
@@ -47,6 +98,29 @@ coverage.xml
 # pyenv
 .python-version
 
+# pipenv
+Pipfile.lock
+
+# poetry
+poetry.lock
+
+# Celery
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
 # mypy
 .mypy_cache/
 .dmypy.json
@@ -55,36 +129,27 @@ dmypy.json
 # Pyre type checker
 .pyre/
 
-# VS Code
-.vscode/
+# pytype static type analyzer
+.pytype/
 
-# PyCharm
-.idea/
+# Cython debug symbols
+cython_debug/
 
-# Local envs
-.env
-.venv
-env/
-venv/
-ENV/
-env.bak/
-venv.bak/
+# Local development
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
 
-# MacOS
-.DS_Store
+# FastAPI
+.pytest_cache/
+.coverage
+htmlcov/
 
-# Windows
-Thumbs.db
-ehthumbs.db
-Desktop.ini
+# Streamlit
+.streamlit/secrets.toml
 
-# MinIO test data
-minio_data/
-minio_test/
-minio/
-
-# Logs
-*.log
-
-# Streamlit cache
-.streamlit/
+# Node.js (if any frontend components)
+node_modules/
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log* 

CLEANUP_SUMMARY.md

@@ -0,0 +1,39 @@
+# 🧹 Сводка по очистке проекта
+
+## ✅ Что было удалено из `python_parser/`:
+
+### Файлы Streamlit:
+- `streamlit_app.py` - основной файл Streamlit приложения
+- `run_streamlit.py` - скрипт запуска Streamlit
+- `Procfile` - конфигурация для Heroku (Streamlit)
+- `runtime.txt` - версия Python для Heroku
+- `manifest.yml` - манифест приложения
+- `.streamlit/` - папка с конфигурацией Streamlit
+
+### Зависимости:
+- Удален `streamlit>=1.28.0` из `python_parser/requirements.txt`
+
+## 🎯 Результат:
+
+### `python_parser/` - теперь содержит ТОЛЬКО:
+- FastAPI приложение
+- Адаптеры для парсеров
+- Основную бизнес-логику
+- Dockerfile для FastAPI
+- Зависимости только для FastAPI
+
+### `streamlit_app/` - содержит ТОЛЬКО:
+- Streamlit приложение
+- Dockerfile для Streamlit
+- Зависимости только для Streamlit
+- Конфигурацию Streamlit
+
+## 🔄 Полное разделение достигнуто:
+
+- **FastAPI** и **Streamlit** теперь полностью независимы
+- Каждый сервис имеет свои собственные зависимости
+- Docker образы собираются отдельно
+- Запускаются через единый `docker-compose.yml`
+
+---
+**Статус**: ✅ Проект полностью очищен и разделен 

QUICK_START.md

@@ -0,0 +1,41 @@
+# 🚀 Быстрый запуск проекта
+
+## 1. Запуск всех сервисов
+```bash
+docker compose up -d
+```
+
+## 2. Проверка статуса
+```bash
+docker compose ps
+```
+
+## 3. Доступ к сервисам
+- **FastAPI**: http://localhost:8000
+- **Streamlit**: http://localhost:8501  
+- **MinIO Console**: http://localhost:9001
+- **MinIO API**: http://localhost:9000
+
+## 4. Остановка
+```bash
+docker compose down
+```
+
+## 5. Просмотр логов
+```bash
+# Все сервисы
+docker compose logs
+
+# Конкретный сервис
+docker compose logs fastapi
+docker compose logs streamlit
+docker compose logs minio
+```
+
+## 6. Пересборка и перезапуск
+```bash
+docker compose up -d --build
+```
+
+---
+**Примечание**: При первом запуске Docker будет скачивать образы и собирать контейнеры, это может занять несколько минут. 

README.md

@@ -0,0 +1,117 @@
+# Python Parser CF - Система анализа данных
+
+Проект состоит из трех основных компонентов:
+- **python_parser** - FastAPI приложение для парсинга и обработки данных
+- **streamlit_app** - Streamlit приложение для визуализации и анализа
+- **minio_data** - хранилище данных MinIO
+
+## 🚀 Быстрый запуск
+
+### Предварительные требования
+- Docker и Docker Compose
+- Git
+
+### Запуск всех сервисов (продакшн)
+```bash
+docker compose up -d
+```
+
+### Запуск в режиме разработки
+```bash
+# Автоматический запуск
+python start_dev.py
+
+# Или вручную
+docker compose -f docker-compose.dev.yml up -d
+```
+
+**Режим разработки** позволяет:
+- Автоматически перезагружать Streamlit при изменении кода
+- Монтировать исходный код напрямую в контейнер
+- Видеть изменения без пересборки контейнеров
+
+### Доступ к сервисам
+- **FastAPI**: http://localhost:8000
+- **Streamlit**: http://localhost:8501
+- **MinIO Console**: http://localhost:9001
+- **MinIO API**: http://localhost:9000
+
+### Остановка сервисов
+```bash
+docker-compose down
+```
+
+## 📁 Структура проекта
+
+```
+python_parser_cf/
+├── python_parser/          # FastAPI приложение
+│   ├── app/               # Основной код приложения
+│   ├── adapters/          # Адаптеры для парсеров
+│   ├── core/              # Основная бизнес-логика
+│   ├── data/              # Тестовые данные
+│   └── Dockerfile         # Docker образ для FastAPI
+├── streamlit_app/          # Streamlit приложение
+│   ├── streamlit_app.py   # Основной файл приложения
+│   ├── requirements.txt    # Зависимости Python
+│   ├── .streamlit/        # Конфигурация Streamlit
+│   └── Dockerfile         # Docker образ для Streamlit
+├── minio_data/            # Данные для MinIO
+├── docker-compose.yml     # Конфигурация всех сервисов
+└── README.md              # Документация
+```
+
+## 🔧 Конфигурация
+
+### Переменные окружения
+Все сервисы используют следующие переменные окружения:
+- `MINIO_ENDPOINT` - адрес MinIO сервера
+- `MINIO_ACCESS_KEY` - ключ доступа к MinIO
+- `MINIO_SECRET_KEY` - секретный ключ MinIO
+- `MINIO_SECURE` - использование SSL/TLS
+- `MINIO_BUCKET` - имя bucket'а для данных
+
+### Порты
+- **8000** - FastAPI
+- **8501** - Streamlit
+- **9000** - MinIO API
+- **9001** - MinIO Console
+
+## 📊 Использование
+
+1. **Запустите все сервисы**: `docker-compose up -d`
+2. **Откройте Streamlit**: http://localhost:8501
+3. **Выберите тип данных** для анализа
+4. **Просматривайте результаты** в интерактивном интерфейсе
+
+## 🛠️ Разработка
+
+### Режим разработки (рекомендуется)
+```bash
+# Запуск режима разработки
+python start_dev.py
+
+# Остановка
+docker compose -f docker-compose.dev.yml down
+
+# Возврат к продакшн режиму
+python start_prod.py
+```
+
+### Локальная разработка FastAPI
+```bash
+cd python_parser
+pip install -r requirements.txt
+uvicorn app.main:app --reload
+```
+
+### Локальная разработка Streamlit
+```bash
+cd streamlit_app
+pip install -r requirements.txt
+streamlit run streamlit_app.py
+```
+
+## 📝 Лицензия
+
+Проект разработан для внутреннего использования. 

docker-compose.dev.yml

@@ -0,0 +1,58 @@
+services:
+  minio:
+    image: minio/minio:latest
+    container_name: svodka_minio_dev
+    ports:
+      - "9000:9000"  # API порт
+      - "9001:9001"  # Консоль порт
+    environment:
+      MINIO_ROOT_USER: minioadmin
+      MINIO_ROOT_PASSWORD: minioadmin
+    command: server /data --console-address ":9001"
+    volumes:
+      - ./minio_data:/data
+    restart: unless-stopped
+
+  fastapi:
+    build: ./python_parser
+    container_name: svodka_fastapi_dev
+    ports:
+      - "8000:8000"
+    environment:
+      - MINIO_ENDPOINT=minio:9000
+      - MINIO_ACCESS_KEY=minioadmin
+      - MINIO_SECRET_KEY=minioadmin
+      - MINIO_SECURE=false
+      - MINIO_BUCKET=svodka-data
+    depends_on:
+      - minio
+    restart: unless-stopped
+
+  streamlit:
+    image: python:3.11-slim
+    container_name: svodka_streamlit_dev
+    ports:
+      - "8501:8501"
+    environment:
+      - API_BASE_URL=http://fastapi:8000
+      - API_PUBLIC_URL=http://localhost:8000
+      - MINIO_ENDPOINT=minio:9000
+      - MINIO_ACCESS_KEY=minioadmin
+      - MINIO_SECRET_KEY=minioadmin
+      - MINIO_SECURE=false
+      - MINIO_BUCKET=svodka-data
+    volumes:
+      # Монтируем исходный код для автоматической перезагрузки
+      - ./streamlit_app:/app
+      # Монтируем requirements.txt для установки зависимостей
+      - ./streamlit_app/requirements.txt:/app/requirements.txt
+    working_dir: /app
+    depends_on:
+      - minio
+      - fastapi
+    restart: unless-stopped
+    command: >
+      bash -c "
+        pip install --no-cache-dir -r requirements.txt &&
+        streamlit run streamlit_app.py --server.port=8501 --server.address=0.0.0.0 --server.runOnSave=true
+      " 

docker-compose.yml

@@ -1,3 +1,5 @@
+# Продакшн конфигурация
+# Для разработки используйте: docker compose -f docker-compose.dev.yml up -d
 services:
   minio:
     image: minio/minio:latest
@@ -10,11 +12,11 @@ services:
       MINIO_ROOT_PASSWORD: minioadmin
     command: server /data --console-address ":9001"
     volumes:
-      - minio_data:/data
+      - ./minio_data:/data
     restart: unless-stopped
 
   fastapi:
-    build: .
+    build: ./python_parser
     container_name: svodka_fastapi
     ports:
       - "8000:8000"
@@ -35,9 +37,13 @@ services:
       - "8501:8501"
     environment:
       - API_BASE_URL=http://fastapi:8000
+      - API_PUBLIC_URL=http://localhost:8000
+      - MINIO_ENDPOINT=minio:9000
+      - MINIO_ACCESS_KEY=minioadmin
+      - MINIO_SECRET_KEY=minioadmin
+      - MINIO_SECURE=false
+      - MINIO_BUCKET=svodka-data
     depends_on:
+      - minio
       - fastapi
     restart: unless-stopped 
-
-volumes:
-  minio_data: 

python_parser/.streamlit/config.toml

@@ -1,28 +0,0 @@
-[server]
-port = 8501
-address = "localhost"
-headless = false
-enableCORS = false
-enableXsrfProtection = false
-
-[browser]
-gatherUsageStats = false
-serverAddress = "localhost"
-serverPort = 8501
-
-[theme]
-primaryColor = "#FF4B4B"
-backgroundColor = "#FFFFFF"
-secondaryBackgroundColor = "#F0F2F6"
-textColor = "#262730"
-font = "sans serif"
-
-[client]
-showErrorDetails = true
-caching = true
-displayEnabled = true
-
-[runner]
-magicEnabled = true
-installTracer = false
-fixMatplotlib = true 

python_parser/Dockerfile_

@@ -1,20 +0,0 @@
-FROM repo-dev.predix.rosneft.ru/python:3.11-slim
-
-WORKDIR /app
-
-# RUN pip install kafka-python==2.0.2
-# RUN pip freeze > /app/requirements.txt
-
-# ADD . /app
-COPY requirements.txt .
-
-RUN mkdir -p vendor
-RUN pip download -r /app/requirements.txt --no-binary=:none: -d /app/vendor
-
-# ADD . /app
-
-# ENV KAFKA_BROKER=10.234.160.10:9093,10.234.160.10:9094,10.234.160.10:9095
-# ENV KAFKA_UPDATE_ALGORITHM_RULES_TOPIC=algorithm-rule-update
-# ENV KAFKA_CLIENT_USERNAME=cf-service
-
-# CMD ["python", "/app/run_dev.py"]

python_parser/Procfile

@@ -1 +0,0 @@
-web: python /app/run_stand.py

python_parser/QUICK_START.md

@@ -1,66 +0,0 @@
-# 🚀 Быстрый старт NIN Excel Parsers API
-
-## 🐳 Запуск через Docker (рекомендуется)
-
-### Вариант 1: MinIO + FastAPI в Docker
-```bash
-# Запуск всех сервисов
-docker-compose up -d --build
-
-# Проверка
-curl http://localhost:8000
-curl http://localhost:9001
-```
-
-### Вариант 2: Только MinIO в Docker
-```bash
-# Запуск только MinIO
-docker-compose up -d minio
-
-# Проверка
-curl http://localhost:9001
-```
-
-## 🖥️ Запуск FastAPI локально
-
-```bash
-# Если MinIO в Docker
-python run_dev.py
-
-# Проверка
-curl http://localhost:8000
-```
-
-## 📊 Запуск Streamlit
-
-```bash
-# В отдельном терминале
-python run_streamlit.py
-```
-
-## 🌐 Доступные URL
-
-- **FastAPI API**: http://localhost:8000
-- **API документация**: http://localhost:8000/docs
-- **MinIO консоль**: http://localhost:9001
-- **Streamlit интерфейс**: http://localhost:8501
-
-## 🛑 Остановка
-
-```bash
-# Остановка Docker
-docker-compose down
-
-# Остановка Streamlit
-# Ctrl+C в терминале
-```
-
-## 🔧 Диагностика
-
-```bash
-# Проверка состояния
-python check_services.py
-
-# Просмотр логов Docker
-docker-compose logs
-``` 

python_parser/README.md

@@ -1,143 +0,0 @@
-# NIN Excel Parsers API
-
-API для парсинга Excel отчетов нефтеперерабатывающих заводов (НПЗ) с использованием FastAPI и MinIO для хранения данных.
-
-## 🚀 Быстрый запуск
-
-### **Вариант 1: Все сервисы в Docker (рекомендуется)**
-```bash
-# Запуск всех сервисов: MinIO + FastAPI + Streamlit
-docker-compose up -d
-
-# Доступ:
-# - MinIO Console: http://localhost:9001
-# - FastAPI: http://localhost:8000
-# - Streamlit: http://localhost:8501
-# - API Docs: http://localhost:8000/docs
-```
-
-### **Вариант 2: Только MinIO в Docker + FastAPI локально**
-```bash
-# Запуск MinIO в Docker
-docker-compose up -d minio
-
-# Запуск FastAPI локально
-python run_dev.py
-
-# В отдельном терминале запуск Streamlit
-cd streamlit_app
-streamlit run app.py
-```
-
-### **Вариант 3: Только MinIO в Docker**
-```bash
-# Запуск только MinIO
-docker-compose up -d minio
-```
-
-## 📋 Описание сервисов
-
-- **MinIO** (порт 9000-9001): S3-совместимое хранилище для данных
-- **FastAPI** (порт 8000): API сервер для парсинга Excel файлов
-- **Streamlit** (порт 8501): Веб-интерфейс для демонстрации API
-
-## 🛑 Остановка
-
-### Остановка Docker сервисов:
-```bash
-# Все сервисы
-docker-compose down
-
-# Только MinIO
-docker-compose stop minio
-```
-
-### Остановка локальных сервисов:
-```bash
-# Нажмите Ctrl+C в терминале с FastAPI/Streamlit
-```
-
-## 📁 Структура проекта
-
-```
-python_parser/
-├── app/                    # FastAPI приложение
-│   ├── main.py           # Основной файл приложения
-│   └── schemas/          # Pydantic схемы
-├── core/                  # Бизнес-логика
-│   ├── models.py         # Модели данных
-│   ├── ports.py          # Интерфейсы (порты)
-│   └── services.py       # Сервисы
-├── adapters/              # Адаптеры для внешних систем
-│   ├── storage.py        # MinIO адаптер
-│   └── parsers/          # Парсеры Excel файлов
-├── streamlit_app/         # Изолированный Streamlit пакет
-│   ├── app.py            # Основное Streamlit приложение
-│   ├── requirements.txt  # Зависимости Streamlit
-│   ├── Dockerfile        # Docker образ для Streamlit
-│   └── .streamlit/       # Конфигурация Streamlit
-├── data/                  # Тестовые данные
-├── docker-compose.yml     # Docker Compose конфигурация
-├── Dockerfile            # Docker образ для FastAPI
-└── run_dev.py            # Запуск FastAPI локально
-```
-
-## 🔍 Доступные эндпоинты
-
-- **GET /** - Информация об API
-- **GET /docs** - Swagger документация
-- **GET /parsers** - Список доступных парсеров
-- **GET /parsers/{parser_name}/getters** - Информация о геттерах парсера
-- **POST /svodka_pm/upload-zip** - Загрузка сводок ПМ
-- **POST /svodka_ca/upload** - Загрузка сводок ЦА
-- **POST /monitoring_fuel/upload-zip** - Загрузка мониторинга топлива
-- **POST /svodka_pm/get_data** - Получение данных сводок ПМ
-- **POST /svodka_ca/get_data** - Получение данных сводок ЦА
-- **POST /monitoring_fuel/get_data** - Получение данных мониторинга топлива
-
-## 📊 Поддерживаемые типы отчетов
-
-1. **svodka_pm** - Сводки по переработке нефти (ПМ)
-   - Геттеры: `single_og`, `total_ogs`
-2. **svodka_ca** - Сводки по переработке нефти (ЦА)
-   - Геттеры: `get_data`
-3. **monitoring_fuel** - Мониторинг топлива
-   - Геттеры: `total_by_columns`, `month_by_code`
-
-## 🏗️ Архитектура
-
-Проект использует **Hexagonal Architecture (Ports and Adapters)**:
-
-- **Порты (Ports)**: Интерфейсы для бизнес-логики
-- **Адаптеры (Adapters)**: Реализации для внешних систем
-- **Сервисы (Services)**: Бизнес-логика приложения
-
-### Система геттеров парсеров
-
-Каждый парсер может иметь несколько методов получения данных (геттеров):
-- Регистрация геттеров в словаре с метаданными
-- Валидация параметров для каждого геттера
-- Единый интерфейс `get_value(getter_name, params)`
-
-## 🐳 Docker
-
-### Сборка образов:
-```bash
-# FastAPI
-docker build -t nin-fastapi .
-
-# Streamlit
-docker build -t nin-streamlit ./streamlit_app
-```
-
-### Запуск отдельных сервисов:
-```bash
-# Только MinIO
-docker-compose up -d minio
-
-# MinIO + FastAPI
-docker-compose up -d minio fastapi
-
-# Все сервисы
-docker-compose up -d
-``` 

python_parser/README_STREAMLIT.md

@@ -1,186 +0,0 @@
-# 🚀 Streamlit Demo для NIN Excel Parsers API
-
-## Описание
-
-Streamlit приложение для демонстрации работы всех API эндпоинтов NIN Excel Parsers. Предоставляет удобный веб-интерфейс для тестирования функциональности парсеров.
-
-## Возможности
-
-- 📤 **Загрузка файлов**: Загрузка ZIP архивов и Excel файлов
-- 📊 **Сводки ПМ**: Работа с плановыми и фактическими данными
-- 🏭 **Сводки СА**: Парсинг сводок центрального аппарата
-- ⛽ **Мониторинг топлива**: Анализ данных по топливу
-- 📱 **Адаптивный интерфейс**: Удобное использование на всех устройствах
-
-## Установка и запуск
-
-### 1. Установка зависимостей
-
-```bash
-pip install -r requirements.txt
-```
-
-### 2. Запуск FastAPI сервера
-
-В одном терминале:
-```bash
-python run_dev.py
-```
-
-### 3. Запуск Streamlit приложения
-
-В другом терминале:
-```bash
-python run_streamlit.py
-```
-
-Или напрямую:
-```bash
-streamlit run streamlit_app.py
-```
-
-### 4. Открытие в браузере
-
-Приложение автоматически откроется по адресу: http://localhost:8501
-
-## Конфигурация
-
-### Переменные окружения
-
-```bash
-# URL API сервера
-export API_BASE_URL="http://localhost:8000"
-
-# Порт Streamlit
-export STREAMLIT_PORT="8501"
-
-# Хост Streamlit
-export STREAMLIT_HOST="localhost"
-```
-
-### Настройки Streamlit
-
-Файл `.streamlit/config.toml` содержит настройки:
-- Порт: 8501
-- Хост: localhost
-- Тема: Кастомная цветовая схема
-- Безопасность: Отключены CORS и XSRF для локальной разработки
-
-## Структура приложения
-
-### Вкладки
-
-1. **📤 Загрузка файлов**
-   - Загрузка сводок ПМ (ZIP)
-   - Загрузка мониторинга топлива (ZIP)
-   - Загрузка сводки СА (Excel)
-
-2. **📊 Сводки ПМ**
-   - Данные по одному ОГ
-   - Данные по всем ОГ
-   - Выбор кодов строк и столбцов
-
-3. **🏭 Сводки СА**
-   - Выбор режимов (план/факт/норматив)
-   - Выбор таблиц для анализа
-
-4. **⛽ Мониторинг топлива**
-   - Агрегация по колонкам
-   - Данные за конкретный месяц
-
-### Боковая панель
-
-- Информация о сервере (PID, CPU, память)
-- Список доступных парсеров
-- Статус подключения к API
-
-## Использование
-
-### 1. Загрузка файлов
-
-1. Выберите соответствующий тип файла
-2. Нажмите "Загрузить"
-3. Дождитесь подтверждения загрузки
-
-### 2. Получение данных
-
-1. Выберите нужные параметры (ОГ, коды, столбцы)
-2. Нажмите "Получить данные"
-3. Результат отобразится в JSON формате
-
-### 3. Мониторинг
-
-- Проверяйте статус API в верхней части
-- Следите за логами операций
-- Используйте индикаторы загрузки
-
-## Устранение неполадок
-
-### API недоступен
-
-```bash
-# Проверьте, запущен ли FastAPI сервер
-curl http://localhost:8000/
-
-# Проверьте порт
-netstat -an | grep 8000
-```
-
-### Streamlit не запускается
-
-```bash
-# Проверьте версию Python
-python --version
-
-# Переустановите Streamlit
-pip uninstall streamlit
-pip install streamlit
-
-# Проверьте порт 8501
-netstat -an | grep 8501
-```
-
-### Ошибки загрузки файлов
-
-- Убедитесь, что файл соответствует формату
-- Проверьте размер файла (не более 100MB)
-- Убедитесь, что MinIO запущен
-
-## Разработка
-
-### Добавление новых функций
-
-1. Создайте новую вкладку в `streamlit_app.py`
-2. Добавьте соответствующие API вызовы
-3. Обновите боковую панель при необходимости
-
-### Кастомизация темы
-
-Отредактируйте `.streamlit/config.toml`:
-```toml
-[theme]
-primaryColor = "#FF4B4B"
-backgroundColor = "#FFFFFF"
-# ... другие цвета
-```
-
-### Добавление новых парсеров
-
-1. Создайте парсер в `adapters/parsers/`
-2. Добавьте в `main.py`
-3. Обновите Streamlit интерфейс
-
-## Безопасность
-
-⚠️ **Внимание**: Приложение настроено для локальной разработки
-- CORS отключен
-- XSRF защита отключена
-- Не используйте в продакшене без дополнительной настройки
-
-## Поддержка
-
-При возникновении проблем:
-1. Проверьте логи в терминале
-2. Убедитесь, что все сервисы запущены
-3. Проверьте конфигурацию
-4. Обратитесь к документации API: http://localhost:8000/docs 

python_parser/adapters/parsers/monitoring_fuel.py

@@ -1,9 +1,9 @@
 import pandas as pd
 import re
-import zipfile
-from typing import Dict, Tuple
+from typing import Dict
+
 from core.ports import ParserPort
-from adapters.pconfig import data_to_json
+from adapters.pconfig import data_to_json, get_object_by_name
 
 
 class MonitoringFuelParser(ParserPort):
@@ -11,82 +11,6 @@ class MonitoringFuelParser(ParserPort):
 
     name = "Мониторинг топлива"
 
-    def _register_default_getters(self):
-        """Регистрация геттеров по умолчанию"""
-        self.register_getter(
-            name="total_by_columns",
-            method=self._get_total_by_columns,
-            required_params=["columns"],
-            optional_params=[],
-            description="Агрегация данных по колонкам"
-        )
-        
-        self.register_getter(
-            name="month_by_code",
-            method=self._get_month_by_code,
-            required_params=["month"],
-            optional_params=[],
-            description="Получение данных за конкретный месяц"
-        )
-
-    def _get_total_by_columns(self, params: dict):
-        """Агрегация по колонкам (обертка для совместимости)"""
-        columns = params["columns"]
-        if not columns:
-            raise ValueError("Отсутствуют идентификаторы столбцов")
-        
-        # TODO: Переделать под новую архитектуру
-        df_means, _ = self.aggregate_by_columns(self.df, columns)
-        return df_means.to_dict(orient='index')
-
-    def _get_month_by_code(self, params: dict):
-        """Получение данных за месяц (обертка для совместимости)"""
-        month = params["month"]
-        if not month:
-            raise ValueError("Отсутствует идентификатор месяца")
-        
-        # TODO: Переделать под новую архитектуру
-        df_month = self.get_month(self.df, month)
-        return df_month.to_dict(orient='index')
-
-    def parse(self, file_path: str, params: dict) -> pd.DataFrame:
-        """Парсинг файла и возврат DataFrame"""
-        # Сохраняем DataFrame для использования в геттерах
-        self.df = self.parse_monitoring_fuel_files(file_path, params)
-        return self.df
-
-    def parse_monitoring_fuel_files(self, zip_path: str, params: dict) -> Dict[str, pd.DataFrame]:
-        """Парсинг ZIP архива с файлами мониторинга топлива"""
-        df_monitorings = {}  # ЭТО СЛОВАРЬ ДАТАФРЕЙМОВ, ГДЕ КЛЮЧ - НОМЕР МЕСЯЦА, ЗНАЧЕНИЕ - ДАТАФРЕЙМ
-
-        with zipfile.ZipFile(zip_path, 'r') as zip_ref:
-
-            file_list = zip_ref.namelist()
-            for month in range(1, 13):
-
-                mm = f"{month:02d}"
-                file_temp = f'monitoring_SNPZ_{mm}.xlsm'
-                candidates = [f for f in file_list if file_temp in f]
-
-                if len(candidates) == 1:
-                    file = candidates[0]
-
-                    print(f'Загрузка {file}')
-                    with zip_ref.open(file) as excel_file:
-                        try:
-                            df = self.parse_single(excel_file, 'Мониторинг потребления')
-                            df_monitorings[mm] = df
-
-                            print(f"✅ Данные за месяц {mm} загружены")
-
-                        except Exception as e:
-                            print(f"Ошибка при загрузке файла {file_temp}: {e}")
-
-                else:
-                    print(f"⚠️ Файл не найден: {file_temp}")
-
-        return df_monitorings
-
     def find_header_row(self, file_path: str, sheet: str, search_value: str = "Установка", max_rows: int = 50) -> int:
         """Определение индекса заголовка в Excel по ключевому слову"""
         # Читаем первые max_rows строк без заголовков
@@ -140,15 +64,46 @@ class MonitoringFuelParser(ParserPort):
         # Проверяем, что колонка 'name' существует
         if 'name' in df_full.columns:
             # Применяем функцию get_id_by_name к каждой строке в колонке 'name'
-            # df_full['id'] = df_full['name'].apply(get_object_by_name) # This line was removed as per new_code
-            pass # Placeholder for new_code
+            df_full['id'] = df_full['name'].apply(get_object_by_name)
 
         # Устанавливаем id как индекс
         df_full.set_index('id', inplace=True)
         print(f"Окончательное количество столбцов: {len(df_full.columns)}")
         return df_full
 
-    def aggregate_by_columns(self, df_dict: Dict[str, pd.DataFrame], columns: list) -> Tuple[pd.DataFrame, Dict[str, pd.DataFrame]]:
+    def parse(self, file_path: str, params: dict) -> dict:
+        import zipfile
+        df_monitorings = {}  # ЭТО СЛОВАРЬ ДАТАФРЕЙМОВ, ГДЕ КЛЮЧ - НОМЕР МЕСЯЦА, ЗНАЧЕНИЕ - ДАТАФРЕЙМ
+
+        with zipfile.ZipFile(file_path, 'r') as zip_ref:
+
+            file_list = zip_ref.namelist()
+            for month in range(1, 13):
+
+                mm = f"{month:02d}"
+                file_temp = f'monitoring_SNPZ_{mm}.xlsm'
+                candidates = [f for f in file_list if file_temp in f]
+
+                if len(candidates) == 1:
+                    file = candidates[0]
+
+                    print(f'Загрузка {file}')
+                    with zip_ref.open(file) as excel_file:
+                        try:
+                            df = self.parse_single(excel_file, 'Мониторинг потребления')
+                            df_monitorings[mm] = df
+
+                            print(f"✅ Данные за месяц {mm} загружены")
+
+                        except Exception as e:
+                            print(f"Ошибка при загрузке файла {file_temp}: {e}")
+
+                else:
+                    print(f"⚠️ Файл не найден: {file_temp}")
+
+        return df_monitorings
+
+    def aggregate_by_columns(self, df_dict: Dict[str, pd.DataFrame], columns):
         ''' Служебная функция. Агрегация данных по среднему по определенным колонкам. '''
         all_data = {}  # Для хранения полных данных (месяцы) по каждой колонке
         means = {}     # Для хранения средних
@@ -230,3 +185,22 @@ class MonitoringFuelParser(ParserPort):
         total.name = 'mean'
 
         return total, df_combined
+
+    def get_value(self, df, params):
+        mode = params.get("mode", "total")
+        columns = params.get("columns", None)
+        month = params.get("month", None)
+        data = None
+        if mode == "total":
+            if not columns:
+                raise ValueError("Отсутствуют идентификаторы столбцов")
+            df_means, _ = self.aggregate_by_columns(df, columns)
+            data = df_means.to_dict(orient='index')
+        elif mode == "month":
+            if not month:
+                raise ValueError("Отсутствуют идентификатор месяца")
+            df_month = self.get_month(df, month)
+            data = df_month.to_dict(orient='index')
+
+        json_result = data_to_json(data)
+        return json_result

python_parser/adapters/parsers/svodka_ca.py

@@ -6,148 +6,9 @@ from adapters.pconfig import get_og_by_name
 
 
 class SvodkaCAParser(ParserPort):
-    """Парсер для сводок СА"""
+    """Парсер для сводки СА"""
 
-    name = "Сводки СА"
-
-    def _register_default_getters(self):
-        """Регистрация геттеров по умолчанию"""
-        self.register_getter(
-            name="get_data",
-            method=self._get_data_wrapper,
-            required_params=["modes", "tables"],
-            optional_params=[],
-            description="Получение данных по режимам и таблицам"
-        )
-
-    def _get_data_wrapper(self, params: dict):
-        """Обертка для получения данных (для совместимости)"""
-        modes = params["modes"]
-        tables = params["tables"]
-        
-        if not isinstance(modes, list):
-            raise ValueError("Поле 'modes' должно быть списком")
-        if not isinstance(tables, list):
-            raise ValueError("Поле 'tables' должно быть списком")
-        
-        # TODO: Переделать под новую архитектуру
-        data_dict = {}
-        for mode in modes:
-            data_dict[mode] = self.get_data(self.df, mode, tables)
-        return self.data_dict_to_json(data_dict)
-
-    def parse(self, file_path: str, params: dict) -> pd.DataFrame:
-        """Парсинг файла и возврат DataFrame"""
-        # Сохраняем DataFrame для использования в геттерах
-        self.df = self.parse_svodka_ca(file_path, params)
-        return self.df
-
-    def parse_svodka_ca(self, file_path: str, params: dict) -> dict:
-        """Парсинг сводки СА"""
-        # === Извлечение и фильтрация ===
-        tables = self.extract_all_tables(file_path, sheet_name)
-
-        # Фильтруем таблицы: оставляем только те, где первая строка содержит нужные заголовки
-        filtered_tables = []
-        for table in tables:
-            if table.empty:
-                continue
-            first_row_values = table.iloc[0].astype(str).str.strip().tolist()
-            if any(val in inclusion_list for val in first_row_values):
-                filtered_tables.append(table)
-
-        tables = filtered_tables
-
-        # === Итоговый список таблиц датафреймов ===
-        result_list = []
-
-        for table in tables:
-            if table.empty:
-                continue
-
-            # Получаем первую строку (до удаления)
-            first_row_values = table.iloc[0].astype(str).str.strip().tolist()
-
-            # Находим, какой элемент из inclusion_list присутствует
-            matched_key = None
-            for val in first_row_values:
-                if val in inclusion_list:
-                    matched_key = val
-                    break  # берём первый совпадающий заголовок
-
-            if matched_key is None:
-                continue  # на всякий случай (хотя уже отфильтровано)
-
-            # Удаляем первую строку (заголовок) и сбрасываем индекс
-            df_cleaned = table.iloc[1:].copy().reset_index(drop=True)
-
-            # Пропускаем, если таблица пустая
-            if df_cleaned.empty:
-                continue
-
-            # Первая строка становится заголовком
-            new_header = df_cleaned.iloc[0]  # извлекаем первую строку как потенциальные названия столбцов
-
-            # Преобразуем заголовок: только первый столбец может быть заменён на "name"
-            cleaned_header = []
-
-            # Обрабатываем первый столбец отдельно
-            first_item = new_header.iloc[0] if isinstance(new_header, pd.Series) else new_header[0]
-            first_item_str = str(first_item).strip() if pd.notna(first_item) else ""
-            if first_item_str == "" or first_item_str == "nan":
-                cleaned_header.append("name")
-            else:
-                cleaned_header.append(first_item_str)
-
-            # Остальные столбцы добавляем без изменений (или с минимальной очисткой)
-            for item in new_header[1:]:
-                # Опционально: приводим к строке и убираем лишние пробелы, но не заменяем на "name"
-                item_str = str(item).strip() if pd.notna(item) else ""
-                cleaned_header.append(item_str)
-
-            # Применяем очищенные названия столбцов
-            df_cleaned = df_cleaned[1:]  # удаляем строку с заголовком
-            df_cleaned.columns = cleaned_header
-            df_cleaned = df_cleaned.reset_index(drop=True)
-
-            if matched_key.endswith('**'):
-                cleaned_key = matched_key[:-2]  # удаляем последние **
-            else:
-                cleaned_key = matched_key
-
-            # Добавляем новую колонку с именем параметра
-            df_cleaned["table"] = cleaned_key
-
-            # Проверяем, что колонка 'name' существует
-            if 'name' not in df_cleaned.columns:
-                print(
-                    f"Внимание: колонка 'name' отсутствует в таблице для '{matched_key}'. Пропускаем добавление 'id'.")
-                continue  # или обработать по-другому
-            else:
-                # Применяем функцию get_id_by_name к каждой строке в колонке 'name'
-                df_cleaned['id'] = df_cleaned['name'].apply(get_og_by_name)
-
-            # Удаляем строки, где id — None, NaN или пустой
-            df_cleaned = df_cleaned.dropna(subset=['id'])  # dropna удаляет NaN
-            # Дополнительно: удаляем None (если не поймал dropna)
-            df_cleaned = df_cleaned[df_cleaned['id'].notna() & (df_cleaned['id'].astype(str) != 'None')]
-
-            # Добавляем в словарь
-            result_list.append(df_cleaned)
-
-        # === Объединение и сортировка по id (индекс) и table ===
-        if result_list:
-            combined_df = pd.concat(result_list, axis=0)
-
-            # Сортируем по индексу (id) и по столбцу 'table'
-            combined_df = combined_df.sort_values(by=['id', 'table'], axis=0)
-
-            # Устанавливаем id как индекс
-            # combined_df.set_index('id', inplace=True)
-
-            return combined_df
-        else:
-            return None
+    name = "Сводка СА"
 
     def extract_all_tables(self, file_path, sheet_name=0):
         """Извлекает все таблицы из Excel файла"""
@@ -222,8 +83,8 @@ class SvodkaCAParser(ParserPort):
             return None
         return name.strip()
 
-    def parse_sheet(self, file_path: str, sheet_name: str, inclusion_list: set) -> pd.DataFrame:
-        """Парсинг листа Excel"""
+    def parse_sheet(self, file_path, sheet_name, inclusion_list):
+        """Собственно функция парсинга отчета СА"""
         # === Извлечение и фильтрация ===
         tables = self.extract_all_tables(file_path, sheet_name)
 
@@ -329,6 +190,77 @@ class SvodkaCAParser(ParserPort):
         else:
             return None
 
+    def parse(self, file_path: str, params: dict) -> dict:
+        """Парсинг файла сводки СА"""
+        # === Точка входа. Нужно выгрузить три таблицы: План, Факт и Норматив ===
+        # Выгружаем План в df_ca_plan
+        inclusion_list_plan = {
+            "ТиП, %",
+            "Топливо итого, тонн",
+            "Топливо итого, %",
+            "Топливо на технологию, тонн",
+            "Топливо на технологию, %",
+            "Топливо на энергетику, тонн",
+            "Топливо на энергетику, %",
+            "Потери итого, тонн",
+            "Потери итого, %",
+            "в т.ч. Идентифицированные безвозвратные потери, тонн**",
+            "в т.ч. Идентифицированные безвозвратные потери, %**",
+            "в т.ч. Неидентифицированные потери, тонн**",
+            "в т.ч. Неидентифицированные потери, %**"
+        }
+
+        df_ca_plan = self.parse_sheet(file_path, 'План', inclusion_list_plan)  # ЭТО ДАТАФРЕЙМ ПЛАНА В СВОДКЕ ЦА
+        print(f"\n--- Объединённый и отсортированный План: {df_ca_plan.shape} ---")
+
+        # Выгружаем Факт
+        inclusion_list_fact = {
+            "ТиП, %",
+            "Топливо итого, тонн",
+            "Топливо итого, %",
+            "Топливо на технологию, тонн",
+            "Топливо на технологию, %",
+            "Топливо на энергетику, тонн",
+            "Топливо на энергетику, %",
+            "Потери итого, тонн",
+            "Потери итого, %",
+            "в т.ч. Идентифицированные безвозвратные потери, тонн",
+            "в т.ч. Идентифицированные безвозвратные потери, %",
+            "в т.ч. Неидентифицированные потери, тонн",
+            "в т.ч. Неидентифицированные потери, %"
+        }
+
+        df_ca_fact = self.parse_sheet(file_path, 'Факт', inclusion_list_fact)  # ЭТО ДАТАФРЕЙМ ФАКТА В СВОДКЕ ЦА
+        print(f"\n--- Объединённый и отсортированный Факт: {df_ca_fact.shape} ---")
+
+        # Выгружаем План в df_ca_normativ
+        inclusion_list_normativ = {
+            "Топливо итого, тонн",
+            "Топливо итого, %",
+            "Топливо на технологию, тонн",
+            "Топливо на технологию, %",
+            "Топливо на энергетику, тонн",
+            "Топливо на энергетику, %",
+            "Потери итого, тонн",
+            "Потери итого, %",
+            "в т.ч. Идентифицированные безвозвратные потери, тонн**",
+            "в т.ч. Идентифицированные безвозвратные потери, %**",
+            "в т.ч. Неидентифицированные потери, тонн**",
+            "в т.ч. Неидентифицированные потери, %**"
+        }
+
+        # ЭТО ДАТАФРЕЙМ НОРМАТИВА В СВОДКЕ ЦА
+        df_ca_normativ = self.parse_sheet(file_path, 'Норматив', inclusion_list_normativ)
+
+        print(f"\n--- Объединённый и отсортированный Норматив: {df_ca_normativ.shape} ---")
+
+        df_dict = {
+            "plan": df_ca_plan,
+            "fact": df_ca_fact,
+            "normativ": df_ca_normativ
+        }
+        return df_dict
+
     def data_dict_to_json(self, data_dict):
         ''' Служебная функция для парсинга словаря в json. '''
         def convert_types(obj):
@@ -376,3 +308,17 @@ class SvodkaCAParser(ParserPort):
         filtered_df = df[df['table'].isin(table_values)].copy()
         result_dict = {key: group for key, group in filtered_df.groupby('table')}
         return result_dict
+
+    def get_value(self, df: pd.DataFrame, params: dict):
+
+        modes = params.get("modes")
+        tables = params.get("tables")
+        if not isinstance(modes, list):
+            raise ValueError("Поле 'modes' должно быть списком")
+        if not isinstance(tables, list):
+            raise ValueError("Поле 'tables' должно быть списком")
+        # Собираем данные
+        data_dict = {}
+        for mode in modes:
+            data_dict[mode] = self.get_data(df, mode, tables)
+        return self.data_dict_to_json(data_dict)

python_parser/adapters/parsers/svodka_pm.py

@@ -9,60 +9,6 @@ class SvodkaPMParser(ParserPort):
 
     name = "Сводки ПМ"
 
-    def _register_default_getters(self):
-        """Регистрация геттеров по умолчанию"""
-        self.register_getter(
-            name="single_og",
-            method=self._get_single_og,
-            required_params=["id", "codes", "columns"],
-            optional_params=["search"],
-            description="Получение данных по одному ОГ"
-        )
-        
-        self.register_getter(
-            name="total_ogs",
-            method=self._get_total_ogs,
-            required_params=["codes", "columns"],
-            optional_params=["search"],
-            description="Получение данных по всем ОГ"
-        )
-
-    def _get_single_og(self, params: dict):
-        """Получение данных по одному ОГ (обертка для совместимости)"""
-        og_id = params["id"]
-        codes = params["codes"]
-        columns = params["columns"]
-        search = params.get("search")
-        
-        if not isinstance(codes, list):
-            raise ValueError("Поле 'codes' должно быть списком")
-        if not isinstance(columns, list):
-            raise ValueError("Поле 'columns' должно быть списком")
-        
-        # Здесь нужно получить DataFrame из self.df, но пока используем старую логику
-        # TODO: Переделать под новую архитектуру
-        return self.get_svodka_og(self.df, og_id, codes, columns, search)
-
-    def _get_total_ogs(self, params: dict):
-        """Получение данных по всем ОГ (обертка для совместимости)"""
-        codes = params["codes"]
-        columns = params["columns"]
-        search = params.get("search")
-        
-        if not isinstance(codes, list):
-            raise ValueError("Поле 'codes' должно быть списком")
-        if not isinstance(columns, list):
-            raise ValueError("Поле 'columns' должно быть списком")
-        
-        # TODO: Переделать под новую архитектуру
-        return self.get_svodka_total(self.df, codes, columns, search)
-
-    def parse(self, file_path: str, params: dict) -> pd.DataFrame:
-        """Парсинг файла и возврат DataFrame"""
-        # Сохраняем DataFrame для использования в геттерах
-        self.df = self.parse_svodka_pm_files(file_path, params)
-        return self.df
-
     def find_header_row(self, file: str, sheet: str, search_value: str = "Итого", max_rows: int = 50) -> int:
         """Определения индекса заголовка в excel по ключевому слову"""
         # Читаем первые max_rows строк без заголовков
@@ -153,25 +99,25 @@ class SvodkaPMParser(ParserPort):
             # Проверяем, является ли колонка пустой/некорректной
             is_empty_or_unnamed = col_str.startswith('Unnamed') or col_str == '' or col_str.lower() == 'nan'
 
-            if is_empty_or_unnamed:
-                # Если это пустая колонка, используем последнее хорошее имя
-                if last_good_name:
-                    new_columns.append(last_good_name)
-                else:
-                    # Если нет хорошего имени, пропускаем
-                    continue
+            # Проверяем, начинается ли на "Итого"
+            if col_str.startswith('Итого'):
+                current_name = 'Итого'
+                last_good_name = current_name  # обновляем last_good_name
+                new_columns.append(current_name)
+            elif is_empty_or_unnamed:
+                # Используем последнее хорошее имя
+                new_columns.append(last_good_name)
             else:
-                # Это хорошая колонка
+                # Имя, полученное из exel
                 last_good_name = col_str
                 new_columns.append(col_str)
 
-        # Применяем новые заголовки
         df_final.columns = new_columns
 
+        print(f"Окончательное количество столбцов: {len(df_final.columns)}")
         return df_final
 
-    def parse_svodka_pm_files(self, zip_path: str, params: dict) -> dict:
-        """Парсинг ZIP архива со сводками ПМ"""
+    def parse(self, file_path: str, params: dict) -> dict:
         import zipfile
         pm_dict = {
             "facts": {},
@@ -179,7 +125,7 @@ class SvodkaPMParser(ParserPort):
         }
         excel_fact_template = 'svodka_fact_pm_ID.xlsm'
         excel_plan_template = 'svodka_plan_pm_ID.xlsx'
-        with zipfile.ZipFile(zip_path, 'r') as zip_ref:
+        with zipfile.ZipFile(file_path, 'r') as zip_ref:
             file_list = zip_ref.namelist()
             for name, id in OG_IDS.items():
                 if id == 'BASH':
@@ -209,9 +155,9 @@ class SvodkaPMParser(ParserPort):
 
         return pm_dict
 
-    def get_svodka_value(self, df_svodka, code, search_value, search_value_filter=None):
-        ''' Служебная функция получения значения по коду и столбцу '''
-        row_index = code
+    def get_svodka_value(self, df_svodka, id, code, search_value=None):
+        ''' Служебная функция для простой выборке по сводке '''
+        row_index = id
 
         mask_value = df_svodka.iloc[0] == code
         if search_value is None:
@@ -308,4 +254,22 @@ class SvodkaPMParser(ParserPort):
 
         return total_result
 
-    # Убираем старый метод get_value, так как он теперь в базовом классе
+    def get_value(self, df, params):
+        og_id = params.get("id")
+        codes = params.get("codes")
+        columns = params.get("columns")
+        search = params.get("search")
+        mode = params.get("mode", "total")
+        if not isinstance(codes, list):
+            raise ValueError("Поле 'codes' должно быть списком")
+        if not isinstance(columns, list):
+            raise ValueError("Поле 'columns' должно быть списком")
+        data = None
+        if mode == "single":
+            if not og_id:
+                raise ValueError("Отсутствует идентификатор ОГ")
+            data = self.get_svodka_og(df, og_id, codes, columns, search)
+        elif mode == "total":
+            data = self.get_svodka_total(df, codes, columns, search)
+        json_result = data_to_json(data)
+        return json_result

python_parser/app/main.py

@@ -96,54 +96,6 @@ async def get_available_parsers():
     return {"parsers": parsers}
 
 
-@app.get("/parsers/{parser_name}/getters", tags=["Общее"],
-         summary="Информация о геттерах парсера",
-         description="Возвращает информацию о доступных геттерах для указанного парсера",
-         responses={
-             200: {
-                 "content": {
-                     "application/json": {
-                         "example": {
-                             "parser": "svodka_pm",
-                             "getters": {
-                                 "single_og": {
-                                     "required_params": ["id", "codes", "columns"],
-                                     "optional_params": ["search"],
-                                     "description": "Получение данных по одному ОГ"
-                                 },
-                                 "total_ogs": {
-                                     "required_params": ["codes", "columns"],
-                                     "optional_params": ["search"],
-                                     "description": "Получение данных по всем ОГ"
-                                 }
-                             }
-                         }
-                     }
-                 }
-             },
-             404: {
-                 "description": "Парсер не найден"
-             }
-         })
-async def get_parser_getters(parser_name: str):
-    """Получение информации о геттерах парсера"""
-    if parser_name not in PARSERS:
-        raise HTTPException(
-            status_code=status.HTTP_404_NOT_FOUND,
-            detail=f"Парсер '{parser_name}' не найден"
-        )
-    
-    parser_class = PARSERS[parser_name]
-    parser_instance = parser_class()
-    
-    getters_info = parser_instance.get_available_getters()
-    
-    return {
-        "parser": parser_name,
-        "getters": getters_info
-    }
-
-
 @app.get("/server-info", tags=["Общее"],
          summary="Информация о сервере",
          response_model=ServerInfoResponse,)

python_parser/core/ports.py

@@ -2,93 +2,28 @@
 Порты (интерфейсы) для hexagonal architecture
 """
 from abc import ABC, abstractmethod
-from typing import Optional, Dict, List, Any, Callable
+from typing import Optional
 import pandas as pd
 
 
 class ParserPort(ABC):
-    """Интерфейс для парсеров с поддержкой множественных геттеров"""
-
-    def __init__(self):
-        """Инициализация с пустым словарем геттеров"""
-        self.getters: Dict[str, Dict[str, Any]] = {}
-        self._register_default_getters()
-
-    def _register_default_getters(self):
-        """Регистрация геттеров по умолчанию - переопределяется в наследниках"""
-        pass
-
-    def register_getter(self, name: str, method: Callable, required_params: List[str], 
-                       optional_params: List[str] = None, description: str = ""):
-        """
-        Регистрация нового геттера
-        
-        Args:
-            name: Имя геттера
-            method: Метод для выполнения
-            required_params: Список обязательных параметров
-            optional_params: Список необязательных параметров
-            description: Описание геттера
-        """
-        if optional_params is None:
-            optional_params = []
-            
-        self.getters[name] = {
-            "method": method,
-            "required_params": required_params,
-            "optional_params": optional_params,
-            "description": description
-        }
-
-    def get_available_getters(self) -> Dict[str, Dict[str, Any]]:
-        """Получение списка доступных геттеров с их описанием"""
-        return {
-            name: {
-                "required_params": info["required_params"],
-                "optional_params": info["optional_params"],
-                "description": info["description"]
-            }
-            for name, info in self.getters.items()
-        }
-
-    # Добавить схему
-    def get_value(self, getter_name: str, params: Dict[str, Any]):
-        """
-        Получение значения через указанный геттер
-        
-        Args:
-            getter_name: Имя геттера
-            params: Параметры для геттера
-            
-        Returns:
-            Результат выполнения геттера
-            
-        Raises:
-            ValueError: Если геттер не найден или параметры неверны
-        """
-        if getter_name not in self.getters:
-            available = list(self.getters.keys())
-            raise ValueError(f"Геттер '{getter_name}' не найден. Доступные: {available}")
-        
-        getter_info = self.getters[getter_name]
-        required = getter_info["required_params"]
-        
-        # Проверка обязательных параметров
-        missing = [p for p in required if p not in params]
-        if missing:
-            raise ValueError(f"Отсутствуют обязательные параметры для геттера '{getter_name}': {missing}")
-        
-        # Вызов метода геттера
-        try:
-            return getter_info["method"](params)
-        except Exception as e:
-            raise ValueError(f"Ошибка выполнения геттера '{getter_name}': {str(e)}")
+    """Интерфейс для парсеров"""
 
     @abstractmethod
     def parse(self, file_path: str, params: dict) -> pd.DataFrame:
         """Парсинг файла и возврат DataFrame"""
         pass
 
+    @abstractmethod
+    def get_value(self, df: pd.DataFrame, params: dict):
+        """Получение значения из DataFrame по параметрам"""
+        pass
+
+    # @abstractmethod
+    # def get_schema(self) -> dict:
+    #     """Возвращает схему входных параметров для парсера"""
+    #     pass
+
 
 class StoragePort(ABC):
     """Интерфейс для хранилища данных"""

python_parser/core/services.py

@@ -100,34 +100,8 @@ class ReportService:
             # Получаем парсер
             parser = get_parser(request.report_type)
 
-            # Устанавливаем DataFrame в парсер для использования в геттерах
-            parser.df = df
-
-            # Получаем параметры запроса
-            get_params = request.get_params or {}
-            
-            # Определяем имя геттера (по умолчанию используем первый доступный)
-            getter_name = get_params.pop("getter", None)
-            if not getter_name:
-                # Если геттер не указан, берем первый доступный
-                available_getters = list(parser.getters.keys())
-                if available_getters:
-                    getter_name = available_getters[0]
-                    print(f"⚠️ Геттер не указан, используем первый доступный: {getter_name}")
-                else:
-                    return DataResult(
-                        success=False,
-                        message="Парсер не имеет доступных геттеров"
-                    )
-
-            # Получаем значение через указанный геттер
-            try:
-                value = parser.get_value(getter_name, get_params)
-            except ValueError as e:
-                return DataResult(
-                    success=False,
-                    message=f"Ошибка параметров: {str(e)}"
-                )
+            # Получаем значение
+            value = parser.get_value(df, request.get_params)
 
             # Формируем результат
             if value is not None:

python_parser/manifest.yml

@@ -1,17 +0,0 @@
-applications: 
-  - name: nin-python-parser-dev-test
-    buildpack: python_buildpack
-    health-check-type: web
-    services:
-      - logging-shared-dev
-    command: python /app/run_stand.py
-    path: .
-    disk_quota: 2G
-    memory: 4G
-    instances: 1
-    env:
-      MINIO_ENDPOINT: s3-region1.ppc-jv-dev.sibintek.ru
-      MINIO_ACCESS_KEY: 00a70fac02c1208446de
-      MINIO_SECRET_KEY: 1gk9tVYEEoH9ADRxb4kiAuCo6CCISdV6ie0p6oDO
-      MINIO_BUCKET: bucket-476684e7-1223-45ac-a101-8b5aeda487d6
-      MINIO_SECURE: false 

python_parser/minio/.minio.sys/format.json

@@ -1 +0,0 @@
-{"version":"1","format":"xl-single","id":"29118f57-702e-4363-9a41-9f06655e449d","xl":{"version":"3","this":"195a90f4-fc26-46a8-b6d4-0b50b99b1342","sets":[["195a90f4-fc26-46a8-b6d4-0b50b99b1342"]],"distributionAlgo":"SIPMOD+PARITY"}}

python_parser/requirements.txt

@@ -12,4 +12,3 @@ requests>=2.31.0
 # pytest-mock>=3.10.0
 httpx>=0.24.0 
 numpy
-streamlit>=1.28.0

python_parser/run_streamlit_local.py

@@ -1,60 +0,0 @@
-#!/usr/bin/env python3
-"""
-Запуск Streamlit интерфейса локально из изолированного пакета
-"""
-
-import subprocess
-import sys
-import webbrowser
-import os
-
-def main():
-    """Основная функция"""
-    print("🚀 ЗАПУСК STREAMLIT ИЗ ИЗОЛИРОВАННОГО ПАКЕТА")
-    print("=" * 60)
-    print("Убедитесь, что FastAPI сервер запущен на порту 8000")
-    print("=" * 60)
-    
-    # Проверяем, существует ли папка streamlit_app
-    if not os.path.exists("streamlit_app"):
-        print("❌ Папка streamlit_app не найдена")
-        print("Создайте изолированный пакет или используйте docker-compose up -d")
-        return
-    
-    # Переходим в папку streamlit_app
-    os.chdir("streamlit_app")
-    
-    # Проверяем, установлен ли Streamlit
-    try:
-        import streamlit
-        print(f"✅ Streamlit {streamlit.__version__} установлен")
-    except ImportError:
-        print("❌ Streamlit не установлен")
-        print("Установите: pip install -r requirements.txt")
-        return
-    
-    print("\n🚀 Запускаю Streamlit...")
-    print("📍 URL: http://localhost:8501")
-    print("🛑 Для остановки нажмите Ctrl+C")
-    
-    # Открываем браузер
-    try:
-        webbrowser.open("http://localhost:8501")
-        print("✅ Браузер открыт")
-    except Exception as e:
-        print(f"⚠️ Не удалось открыть браузер: {e}")
-    
-    # Запускаем Streamlit
-    try:
-        subprocess.run([
-            sys.executable, "-m", "streamlit", "run", "app.py",
-            "--server.port", "8501",
-            "--server.address", "localhost",
-            "--server.headless", "false",
-            "--browser.gatherUsageStats", "false"
-        ])
-    except KeyboardInterrupt:
-        print("\n👋 Streamlit остановлен")
-
-if __name__ == "__main__":
-    main() 

python_parser/runtime.txt

@@ -1 +0,0 @@
-python-3.11.*

python_parser/streamlit_app/.dockerignore

@@ -1,31 +0,0 @@
-__pycache__
-*.pyc
-*.pyo
-*.pyd
-.Python
-env
-pip-log.txt
-pip-delete-this-directory.txt
-.tox
-.coverage
-.coverage.*
-.cache
-nosetests.xml
-coverage.xml
-*.cover
-*.log
-.git
-.mypy_cache
-.pytest_cache
-.hypothesis
-.DS_Store
-.env
-.venv
-venv/
-ENV/
-env/
-.idea/
-.vscode/
-*.swp
-*.swo
-*~ 

python_parser/streamlit_app/Dockerfile

@@ -1,23 +0,0 @@
-FROM python:3.11-slim
-
-WORKDIR /app
-
-# Устанавливаем системные зависимости
-RUN apt-get update && apt-get install -y \
-    gcc \
-    && rm -rf /var/lib/apt/lists/*
-
-# Копируем файлы зависимостей
-COPY requirements.txt .
-
-# Устанавливаем Python зависимости
-RUN pip install --no-cache-dir -r requirements.txt
-
-# Копируем код приложения
-COPY . .
-
-# Открываем порт
-EXPOSE 8501
-
-# Команда запуска
-CMD ["streamlit", "run", "app.py", "--server.port", "8501", "--server.address", "0.0.0.0"] 

python_parser/streamlit_app/README.md

@@ -1,44 +0,0 @@
-# 📊 Streamlit App - NIN Excel Parsers API
-
-Изолированное Streamlit приложение для демонстрации работы NIN Excel Parsers API.
-
-## 🚀 Запуск
-
-### Локально:
-```bash
-cd streamlit_app
-pip install -r requirements.txt
-streamlit run app.py
-```
-
-### В Docker:
-```bash
-docker build -t streamlit-app .
-docker run -p 8501:8501 streamlit-app
-```
-
-## 🔧 Конфигурация
-
-### Переменные окружения:
-- `API_BASE_URL` - адрес FastAPI сервера (по умолчанию: `http://fastapi:8000`)
-
-### Параметры Streamlit:
-- Порт: 8501
-- Адрес: 0.0.0.0 (для Docker)
-- Режим: headless (для Docker)
-
-## 📁 Структура
-
-```
-streamlit_app/
-├── app.py              # Основное приложение
-├── requirements.txt    # Зависимости Python
-├── Dockerfile         # Docker образ
-├── .streamlit/        # Конфигурация Streamlit
-│   └── config.toml   # Настройки
-└── README.md          # Документация
-```
-
-## 🌐 Доступ
-
-После запуска приложение доступно по адресу: **http://localhost:8501** 

python_parser/streamlit_app/app.py

@@ -1,447 +0,0 @@
-import streamlit as st
-import requests
-import json
-import pandas as pd
-import io
-import zipfile
-from typing import Dict, Any
-import os
-
-# Конфигурация страницы
-st.set_page_config(
-    page_title="NIN Excel Parsers API Demo",
-    page_icon="📊",
-    layout="wide",
-    initial_sidebar_state="expanded"
-)
-
-# Конфигурация API - используем переменную окружения или значение по умолчанию
-API_BASE_URL = os.getenv("API_BASE_URL", "http://fastapi:8000")
-
-def check_api_health():
-    """Проверка доступности API"""
-    try:
-        response = requests.get(f"{API_BASE_URL}/", timeout=5)
-        return response.status_code == 200
-    except:
-        return False
-
-def get_available_parsers():
-    """Получение списка доступных парсеров"""
-    try:
-        response = requests.get(f"{API_BASE_URL}/parsers")
-        if response.status_code == 200:
-            return response.json()["parsers"]
-        return []
-    except:
-        return []
-
-def get_parser_getters(parser_name: str):
-    """Получение информации о геттерах парсера"""
-    try:
-        response = requests.get(f"{API_BASE_URL}/parsers/{parser_name}/getters")
-        if response.status_code == 200:
-            return response.json()
-        return {}
-    except:
-        return {}
-
-def get_server_info():
-    """Получение информации о сервере"""
-    try:
-        response = requests.get(f"{API_BASE_URL}/server-info")
-        if response.status_code == 200:
-            return response.json()
-        return {}
-    except:
-        return {}
-
-def upload_file_to_api(endpoint: str, file_data: bytes, filename: str):
-    """Загрузка файла на API"""
-    try:
-        files = {"zip_file": (filename, file_data, "application/zip")}
-        response = requests.post(f"{API_BASE_URL}{endpoint}", files=files)
-        return response.json(), response.status_code
-    except Exception as e:
-        return {"error": str(e)}, 500
-
-def make_api_request(endpoint: str, data: Dict[str, Any]):
-    """Выполнение API запроса"""
-    try:
-        response = requests.post(f"{API_BASE_URL}{endpoint}", json=data)
-        return response.json(), response.status_code
-    except Exception as e:
-        return {"error": str(e)}, 500
-
-def main():
-    st.title("🚀 NIN Excel Parsers API - Демонстрация")
-    st.markdown("---")
-    
-    # Проверка доступности API
-    if not check_api_health():
-        st.error(f"❌ API недоступен по адресу {API_BASE_URL}")
-        st.info("Убедитесь, что FastAPI сервер запущен")
-        return
-    
-    st.success(f"✅ API доступен по адресу {API_BASE_URL}")
-    
-    # Боковая панель с информацией
-    with st.sidebar:
-        st.header("ℹ️ Информация")
-        
-        # Информация о сервере
-        server_info = get_server_info()
-        if server_info:
-            st.subheader("Сервер")
-            st.write(f"PID: {server_info.get('process_id', 'N/A')}")
-            st.write(f"CPU ядер: {server_info.get('cpu_cores', 'N/A')}")
-            st.write(f"Память: {server_info.get('memory_mb', 'N/A'):.1f} MB")
-        
-        # Доступные парсеры
-        parsers = get_available_parsers()
-        if parsers:
-            st.subheader("Доступные парсеры")
-            for parser in parsers:
-                st.write(f"• {parser}")
-    
-    # Основные вкладки - по одной на каждый парсер
-    tab1, tab2, tab3 = st.tabs([
-        "📊 Сводки ПМ", 
-        "🏭 Сводки СА", 
-        "⛽ Мониторинг топлива"
-    ])
-    
-    # Вкладка 1: Сводки ПМ - полный функционал
-    with tab1:
-        st.header("📊 Сводки ПМ - Полный функционал")
-        
-        # Получаем информацию о геттерах
-        getters_info = get_parser_getters("svodka_pm")
-        
-        # Секция загрузки файлов
-        st.subheader("📤 Загрузка файлов")
-        uploaded_pm = st.file_uploader(
-            "Выберите ZIP архив со сводками ПМ",
-            type=['zip'],
-            key="pm_upload"
-        )
-        
-        if uploaded_pm is not None:
-            if st.button("📤 Загрузить сводки ПМ", key="upload_pm_btn"):
-                with st.spinner("Загружаю файл..."):
-                    result, status = upload_file_to_api(
-                        "/svodka_pm/upload-zip",
-                        uploaded_pm.read(),
-                        uploaded_pm.name
-                    )
-                    
-                    if status == 200:
-                        st.success(f"✅ {result.get('message', 'Файл загружен')}")
-                        st.info(f"ID объекта: {result.get('object_id', 'N/A')}")
-                    else:
-                        st.error(f"❌ Ошибка: {result.get('message', 'Неизвестная ошибка')}")
-        
-        st.markdown("---")
-        
-        # Секция получения данных
-        st.subheader("🔍 Получение данных")
-        
-        # Показываем доступные геттеры
-        if getters_info and "getters" in getters_info:
-            st.info("📋 Доступные геттеры:")
-            for getter_name, getter_info in getters_info["getters"].items():
-                st.write(f"• **{getter_name}**: {getter_info.get('description', 'Нет описания')}")
-                st.write(f"  - Обязательные параметры: {', '.join(getter_info.get('required_params', []))}")
-                if getter_info.get('optional_params'):
-                    st.write(f"  - Необязательные параметры: {', '.join(getter_info['optional_params'])}")
-        
-        col1, col2 = st.columns(2)
-        
-        with col1:
-            st.subheader("Данные по одному ОГ")
-            
-            og_id = st.selectbox(
-                "Выберите ОГ",
-                ["SNPZ", "KNPZ", "ANHK", "AchNPZ", "UNPZ", "UNH", "NOV", 
-                 "NovKuybNPZ", "KuybNPZ", "CyzNPZ", "TuapsNPZ", "RNPK", 
-                 "NVNPO", "KLNPZ", "PurNP", "YANOS"],
-                key="pm_single_og"
-            )
-            
-            codes = st.multiselect(
-                "Выберите коды строк",
-                [78, 79, 394, 395, 396, 397, 81, 82, 83, 84],
-                default=[78, 79],
-                key="pm_single_codes"
-            )
-            
-            columns = st.multiselect(
-                "Выберите столбцы",
-                ["БП", "ПП", "СЭБ", "Факт", "План"],
-                default=["БП", "ПП"],
-                key="pm_single_columns"
-            )
-            
-            if st.button("🔍 Получить данные по ОГ", key="pm_single_btn"):
-                if codes and columns:
-                    with st.spinner("Получаю данные..."):
-                        data = {
-                            "getter": "single_og",
-                            "id": og_id,
-                            "codes": codes,
-                            "columns": columns
-                        }
-                        
-                        result, status = make_api_request("/svodka_pm/get_data", data)
-                        
-                        if status == 200:
-                            st.success("✅ Данные получены")
-                            st.json(result)
-                        else:
-                            st.error(f"❌ Ошибка: {result.get('message', 'Неизвестная ошибка')}")
-                else:
-                    st.warning("⚠️ Выберите коды и столбцы")
-        
-        with col2:
-            st.subheader("Данные по всем ОГ")
-            
-            codes_total = st.multiselect(
-                "Выберите коды строк",
-                [78, 79, 394, 395, 396, 397, 81, 82, 83, 84],
-                default=[78, 79, 394, 395],
-                key="pm_total_codes"
-            )
-            
-            columns_total = st.multiselect(
-                "Выберите столбцы",
-                ["БП", "ПП", "СЭБ", "Факт", "План"],
-                default=["БП", "ПП", "СЭБ"],
-                key="pm_total_columns"
-            )
-            
-            if st.button("🔍 Получить данные по всем ОГ", key="pm_total_btn"):
-                if codes_total and columns_total:
-                    with st.spinner("Получаю данные..."):
-                        data = {
-                            "getter": "total_ogs",
-                            "codes": codes_total,
-                            "columns": columns_total
-                        }
-                        
-                        result, status = make_api_request("/svodka_pm/get_data", data)
-                        
-                        if status == 200:
-                            st.success("✅ Данные получены")
-                            st.json(result)
-                        else:
-                            st.error(f"❌ Ошибка: {result.get('message', 'Неизвестная ошибка')}")
-                else:
-                    st.warning("⚠️ Выберите коды и столбцы")
-    
-    # Вкладка 2: Сводки СА - полный функционал
-    with tab2:
-        st.header("🏭 Сводки СА - Полный функционал")
-        
-        # Получаем информацию о геттерах
-        getters_info = get_parser_getters("svodka_ca")
-        
-        # Секция загрузки файлов
-        st.subheader("📤 Загрузка файлов")
-        uploaded_ca = st.file_uploader(
-            "Выберите Excel файл сводки СА",
-            type=['xlsx', 'xlsm', 'xls'],
-            key="ca_upload"
-        )
-        
-        if uploaded_ca is not None:
-            if st.button("📤 Загрузить сводку СА", key="upload_ca_btn"):
-                with st.spinner("Загружаю файл..."):
-                    try:
-                        files = {"file": (uploaded_ca.name, uploaded_ca.read(), "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet")}
-                        response = requests.post(f"{API_BASE_URL}/svodka_ca/upload", files=files)
-                        result = response.json()
-                        
-                        if response.status_code == 200:
-                            st.success(f"✅ {result.get('message', 'Файл загружен')}")
-                            st.info(f"ID объекта: {result.get('object_id', 'N/A')}")
-                        else:
-                            st.error(f"❌ Ошибка: {result.get('message', 'Неизвестная ошибка')}")
-                    except Exception as e:
-                        st.error(f"❌ Ошибка: {str(e)}")
-        
-        st.markdown("---")
-        
-        # Секция получения данных
-        st.subheader("🔍 Получение данных")
-        
-        # Показываем доступные геттеры
-        if getters_info and "getters" in getters_info:
-            st.info("📋 Доступные геттеры:")
-            for getter_name, getter_info in getters_info["getters"].items():
-                st.write(f"• **{getter_name}**: {getter_info.get('description', 'Нет описания')}")
-                st.write(f"  - Обязательные параметры: {', '.join(getter_info.get('required_params', []))}")
-                if getter_info.get('optional_params'):
-                    st.write(f"  - Необязательные параметры: {', '.join(getter_info['optional_params'])}")
-        
-        col1, col2 = st.columns(2)
-        
-        with col1:
-            st.subheader("Параметры запроса")
-            
-            modes = st.multiselect(
-                "Выберите режимы",
-                ["План", "Факт", "Норматив"],
-                default=["План", "Факт"],
-                key="ca_modes"
-            )
-            
-            tables = st.multiselect(
-                "Выберите таблицы",
-                ["ТиП", "Топливо", "Потери"],
-                default=["ТиП", "Топливо"],
-                key="ca_tables"
-            )
-        
-        with col2:
-            st.subheader("Результат")
-            if st.button("🔍 Получить данные СА", key="ca_btn"):
-                if modes and tables:
-                    with st.spinner("Получаю данные..."):
-                        data = {
-                            "getter": "get_data",
-                            "modes": modes,
-                            "tables": tables
-                        }
-                        
-                        result, status = make_api_request("/svodka_ca/get_data", data)
-                        
-                        if status == 200:
-                            st.success("✅ Данные получены")
-                            st.json(result)
-                        else:
-                            st.error(f"❌ Ошибка: {result.get('message', 'Неизвестная ошибка')}")
-                else:
-                    st.warning("⚠️ Выберите режимы и таблицы")
-    
-    # Вкладка 3: Мониторинг топлива - полный функционал
-    with tab3:
-        st.header("⛽ Мониторинг топлива - Полный функционал")
-        
-        # Получаем информацию о геттерах
-        getters_info = get_parser_getters("monitoring_fuel")
-        
-        # Секция загрузки файлов
-        st.subheader("📤 Загрузка файлов")
-        uploaded_fuel = st.file_uploader(
-            "Выберите ZIP архив с мониторингом топлива",
-            type=['zip'],
-            key="fuel_upload"
-        )
-        
-        if uploaded_fuel is not None:
-            if st.button("📤 Загрузить мониторинг топлива", key="upload_fuel_btn"):
-                with st.spinner("Загружаю файл..."):
-                    result, status = upload_file_to_api(
-                        "/monitoring_fuel/upload-zip",
-                        uploaded_fuel.read(),
-                        uploaded_fuel.name
-                    )
-                    
-                    if status == 200:
-                        st.success(f"✅ {result.get('message', 'Файл загружен')}")
-                        st.info(f"ID объекта: {result.get('object_id', 'N/A')}")
-                    else:
-                        st.error(f"❌ Ошибка: {result.get('message', 'Неизвестная ошибка')}")
-        
-        st.markdown("---")
-        
-        # Секция получения данных
-        st.subheader("🔍 Получение данных")
-        
-        # Показываем доступные геттеры
-        if getters_info and "getters" in getters_info:
-            st.info("📋 Доступные геттеры:")
-            for getter_name, getter_info in getters_info["getters"].items():
-                st.write(f"• **{getter_name}**: {getter_info.get('description', 'Нет описания')}")
-                st.write(f"  - Обязательные параметры: {', '.join(getter_info.get('required_params', []))}")
-                if getter_info.get('optional_params'):
-                    st.write(f"  - Необязательные параметры: {', '.join(getter_info['optional_params'])}")
-        
-        col1, col2 = st.columns(2)
-        
-        with col1:
-            st.subheader("Агрегация по колонкам")
-            
-            columns_fuel = st.multiselect(
-                "Выберите столбцы",
-                ["normativ", "total", "total_1"],
-                default=["normativ", "total"],
-                key="fuel_columns"
-            )
-            
-            if st.button("🔍 Получить агрегированные данные", key="fuel_total_btn"):
-                if columns_fuel:
-                    with st.spinner("Получаю данные..."):
-                        data = {
-                            "getter": "total_by_columns",
-                            "columns": columns_fuel
-                        }
-                        
-                        result, status = make_api_request("/monitoring_fuel/get_data", data)
-                        
-                        if status == 200:
-                            st.success("✅ Данные получены")
-                            st.json(result)
-                        else:
-                            st.error(f"❌ Ошибка: {result.get('message', 'Неизвестная ошибка')}")
-                else:
-                    st.warning("⚠️ Выберите столбцы")
-        
-        with col2:
-            st.subheader("Данные за месяц")
-            
-            month = st.selectbox(
-                "Выберите месяц",
-                [f"{i:02d}" for i in range(1, 13)],
-                key="fuel_month"
-            )
-            
-            if st.button("🔍 Получить данные за месяц", key="fuel_month_btn"):
-                with st.spinner("Получаю данные..."):
-                    data = {
-                        "getter": "month_by_code",
-                        "month": month
-                    }
-                    
-                    result, status = make_api_request("/monitoring_fuel/get_data", data)
-                    
-                    if status == 200:
-                        st.success("✅ Данные получены")
-                        st.json(result)
-                    else:
-                        st.error(f"❌ Ошибка: {result.get('message', 'Неизвестная ошибка')}")
-    
-    # Футер
-    st.markdown("---")
-    st.markdown("### 📚 Документация API")
-    st.markdown(f"Полная документация доступна по адресу: {API_BASE_URL}/docs")
-    
-    # Информация о проекте
-    with st.expander("ℹ️ О проекте"):
-        st.markdown("""
-        **NIN Excel Parsers API** - это веб-сервис для парсинга и обработки Excel-файлов нефтеперерабатывающих заводов.
-        
-        **Возможности:**
-        - 📊 Парсинг сводок ПМ (план и факт)
-        - 🏭 Парсинг сводок СА
-        - ⛽ Мониторинг топлива
-        
-        **Технологии:**
-        - FastAPI
-        - Pandas
-        - MinIO (S3-совместимое хранилище)
-        - Streamlit (веб-интерфейс)
-        """)
-
-if __name__ == "__main__":
-    main() 

python_parser/streamlit_app/requirements.txt

@@ -1,4 +0,0 @@
-streamlit>=1.28.0
-requests>=2.31.0
-pandas>=1.5.0
-numpy>=1.24.0 

start_dev.py

@@ -0,0 +1,49 @@
+#!/usr/bin/env python3
+"""
+Скрипт для запуска проекта в режиме разработки
+"""
+
+import subprocess
+import sys
+import os
+
+def run_command(command, description):
+    """Выполнение команды с выводом"""
+    print(f"🔄 {description}...")
+    try:
+        result = subprocess.run(command, shell=True, check=True, capture_output=True, text=True)
+        print(f"✅ {description} выполнено успешно")
+        return True
+    except subprocess.CalledProcessError as e:
+        print(f"❌ Ошибка при {description.lower()}:")
+        print(f"   Команда: {command}")
+        print(f"   Ошибка: {e.stderr}")
+        return False
+
+def main():
+    print("🚀 Запуск проекта в режиме разработки")
+    print("=" * 50)
+    
+    # Останавливаем продакшн контейнеры если они запущены
+    if run_command("docker compose ps", "Проверка статуса контейнеров"):
+        if "Up" in subprocess.run("docker compose ps", shell=True, capture_output=True, text=True).stdout:
+            print("🛑 Останавливаю продакшн контейнеры...")
+            run_command("docker compose down", "Остановка продакшн контейнеров")
+    
+    # Запускаем режим разработки
+    print("\n🔧 Запуск режима разработки...")
+    if run_command("docker compose -f docker-compose.dev.yml up -d", "Запуск контейнеров разработки"):
+        print("\n🎉 Проект запущен в режиме разработки!")
+        print("\n📍 Доступные сервисы:")
+        print("   • Streamlit: http://localhost:8501")
+        print("   • FastAPI: http://localhost:8000")
+        print("   • MinIO Console: http://localhost:9001")
+        print("\n💡 Теперь изменения в streamlit_app/ будут автоматически перезагружаться!")
+        print("\n🛑 Для остановки используйте:")
+        print("   docker compose -f docker-compose.dev.yml down")
+    else:
+        print("\n❌ Не удалось запустить проект в режиме разработки")
+        sys.exit(1)
+
+if __name__ == "__main__":
+    main() 

start_prod.py

@@ -0,0 +1,49 @@
+#!/usr/bin/env python3
+"""
+Скрипт для запуска проекта в продакшн режиме
+"""
+
+import subprocess
+import sys
+
+def run_command(command, description):
+    """Выполнение команды с выводом"""
+    print(f"🔄 {description}...")
+    try:
+        result = subprocess.run(command, shell=True, check=True, capture_output=True, text=True)
+        print(f"✅ {description} выполнено успешно")
+        return True
+    except subprocess.CalledProcessError as e:
+        print(f"❌ Ошибка при {description.lower()}:")
+        print(f"   Команда: {command}")
+        print(f"   Ошибка: {e.stderr}")
+        return False
+
+def main():
+    print("🚀 Запуск проекта в продакшн режиме")
+    print("=" * 50)
+    
+    # Останавливаем контейнеры разработки если они запущены
+    if run_command("docker compose -f docker-compose.dev.yml ps", "Проверка статуса контейнеров разработки"):
+        if "Up" in subprocess.run("docker compose -f docker-compose.dev.yml ps", shell=True, capture_output=True, text=True).stdout:
+            print("🛑 Останавливаю контейнеры разработки...")
+            run_command("docker compose -f docker-compose.dev.yml down", "Остановка контейнеров разработки")
+    
+    # Запускаем продакшн режим
+    print("\n🏭 Запуск продакшн режима...")
+    if run_command("docker compose up -d --build", "Запуск продакшн контейнеров"):
+        print("\n🎉 Проект запущен в продакшн режиме!")
+        print("\n📍 Доступные сервисы:")
+        print("   • Streamlit: http://localhost:8501")
+        print("   • FastAPI: http://localhost:8000")
+        print("   • MinIO Console: http://localhost:9001")
+        print("\n💡 Для разработки используйте:")
+        print("   python start_dev.py")
+        print("\n🛑 Для остановки используйте:")
+        print("   docker compose down")
+    else:
+        print("\n❌ Не удалось запустить проект в продакшн режиме")
+        sys.exit(1)
+
+if __name__ == "__main__":
+    main() 

streamlit_app/.streamlit/config.toml

@@ -0,0 +1,15 @@
+[server]
+port = 8501
+address = "0.0.0.0"
+enableCORS = false
+enableXsrfProtection = false
+
+[browser]
+gatherUsageStats = false
+
+[theme]
+primaryColor = "#FF4B4B"
+backgroundColor = "#FFFFFF"
+secondaryBackgroundColor = "#F0F2F6"
+textColor = "#262730"
+font = "sans serif" 

streamlit_app/Dockerfile

@@ -0,0 +1,23 @@
+FROM python:3.11-slim
+
+WORKDIR /app
+
+# Установка системных зависимостей
+RUN apt-get update && apt-get install -y \
+    gcc \
+    && rm -rf /var/lib/apt/lists/*
+
+# Копирование requirements.txt
+COPY requirements.txt .
+
+# Установка Python зависимостей
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Копирование кода приложения
+COPY . .
+
+# Открытие порта
+EXPOSE 8501
+
+# Запуск Streamlit
+CMD ["streamlit", "run", "streamlit_app.py", "--server.port=8501", "--server.address=0.0.0.0"] 

streamlit_app/_streamlit_app.py

@@ -0,0 +1,100 @@
+import streamlit as st
+import pandas as pd
+import numpy as np
+import plotly.express as px
+import plotly.graph_objects as go
+from minio import Minio
+import os
+from io import BytesIO
+
+# Конфигурация страницы
+st.set_page_config(
+    page_title="Сводка данных",
+    page_icon="📊",
+    layout="wide",
+    initial_sidebar_state="expanded"
+)
+
+# Заголовок приложения
+st.title("📊 Анализ данных сводки")
+st.markdown("---")
+
+# Инициализация MinIO клиента
+@st.cache_resource
+def init_minio_client():
+    try:
+        client = Minio(
+            os.getenv("MINIO_ENDPOINT", "localhost:9000"),
+            access_key=os.getenv("MINIO_ACCESS_KEY", "minioadmin"),
+            secret_key=os.getenv("MINIO_SECRET_KEY", "minioadmin"),
+            secure=os.getenv("MINIO_SECURE", "false").lower() == "true"
+        )
+        return client
+    except Exception as e:
+        st.error(f"Ошибка подключения к MinIO: {e}")
+        return None
+
+# Боковая панель
+with st.sidebar:
+    st.header("⚙️ Настройки")
+    
+    # Выбор типа данных
+    data_type = st.selectbox(
+        "Тип данных",
+        ["Мониторинг топлива", "Сводка ПМ", "Сводка ЦА"]
+    )
+    
+    # Выбор периода
+    period = st.date_input(
+        "Период",
+        value=pd.Timestamp.now().date()
+    )
+    
+    st.markdown("---")
+    st.markdown("### 📈 Статистика")
+    st.info("Выберите тип данных для анализа")
+
+# Основной контент
+col1, col2 = st.columns([2, 1])
+
+with col1:
+    st.subheader(f"📋 {data_type}")
+    
+    if data_type == "Мониторинг топлива":
+        st.info("Анализ данных мониторинга топлива")
+        # Здесь будет логика для работы с данными мониторинга топлива
+        
+    elif data_type == "Сводка ПМ":
+        st.info("Анализ данных сводки ПМ")
+        # Здесь будет логика для работы с данными сводки ПМ
+        
+    elif data_type == "Сводка ЦА":
+        st.info("Анализ данных сводки ЦА")
+        # Здесь будет логика для работы с данными сводки ЦА
+
+with col2:
+    st.subheader("📊 Быстрая статистика")
+    st.metric("Всего записей", "0")
+    st.metric("Активных", "0")
+    st.metric("Ошибок", "0")
+
+# Нижняя панель
+st.markdown("---")
+st.subheader("🔍 Детальный анализ")
+
+# Заглушка для графиков
+placeholder = st.empty()
+with placeholder.container():
+    col1, col2 = st.columns(2)
+    
+    with col1:
+        st.write("📈 График 1")
+        # Здесь будет график
+        
+    with col2:
+        st.write("📊 График 2")
+        # Здесь будет график
+
+# Футер
+st.markdown("---")
+st.markdown("**Разработано для анализа данных сводки** | v1.0.0") 

streamlit_app/requirements.txt

@@ -0,0 +1,7 @@
+streamlit>=1.28.0
+pandas>=2.0.0
+numpy>=1.24.0
+plotly>=5.15.0
+minio>=7.1.0
+openpyxl>=3.1.0
+xlrd>=2.0.1 

streamlit_app/streamlit_app.py

@@ -16,7 +16,8 @@ st.set_page_config(
 )
 
 # Конфигурация API
-API_BASE_URL = os.getenv("API_BASE_URL", "http://localhost:8000")
+API_BASE_URL = os.getenv("API_BASE_URL", "http://fastapi:8000")  # Внутренний адрес для Docker
+API_PUBLIC_URL = os.getenv("API_PUBLIC_URL", "http://localhost:8000")  # Внешний адрес для пользователя
 
 def check_api_health():
     """Проверка доступности API"""
@@ -73,7 +74,7 @@ def main():
         st.info("Убедитесь, что FastAPI сервер запущен")
         return
     
-    st.success(f"✅ API доступен по адресу {API_BASE_URL}")
+    st.success(f"✅ API доступен по адресу {API_PUBLIC_URL}")
     
     # Боковая панель с информацией
     with st.sidebar:
@@ -373,7 +374,7 @@ def main():
     # Футер
     st.markdown("---")
     st.markdown("### 📚 Документация API")
-    st.markdown(f"Полная документация доступна по адресу: {API_BASE_URL}/docs")
+    st.markdown(f"Полная документация доступна по адресу: {API_PUBLIC_URL}/docs")
     
     # Информация о проекте
     with st.expander("ℹ️ О проекте"):