Dun - Dynamiczny Uniwersalny Narzędziownik

Dynamiczny Uniwersalny Narzędziownik do przetwarzania danych z wykorzystaniem sztucznej inteligencji.

Alternatywnie:

Data Utility Network - Narzędzie do pracy z danymi i siecią

System automatycznego przetwarzania danych z wykorzystaniem LLM (Mistral 7B) do interpretacji żądań w języku naturalnym i dynamicznego instalowania bibliotek Python.

Dun - Dynamiczny Procesor Danych

Note: Używaj komendy dun zamiast python dun.py do uruchamiania programu.

🚀 Funkcje

Interpretacja języka naturalnego: Przetwarzanie żądań w zwykłym języku polskim
Dynamiczne zarządzanie bibliotekami: Automatyczna instalacja wymaganych pakietów Python
Przetwarzanie plików CSV: Łączenie i analiza wielu plików CSV w jeden zbiór danych
Lokalna skrzynka IMAP: Testowa skrzynka pocztowa z przykładowymi wiadomościami
Integracja z Ollama: Wykorzystanie modelu Mistral 7B do analizy żądań
Organizacja plików: Automatyczne sortowanie emaili według dat w strukturze folderów

📂 Przetwarzanie plików CSV

Dun umożliwia łatwe łączenie i analizowanie wielu plików CSV za pomocą prostych poleceń w języku naturalnym. Funkcja ta działa nawet bez dostępu do modelu LLM.

Przykłady użycia

# Przetwórz wszystkie pliki CSV w katalogu data/
dun "Przeanalizuj wszystkie pliki CSV w folderze data/"

# Określ niestandardowy katalog wejściowy i wyjściowy
dun "Połącz pliki CSV z folderu moje_dane i zapisz jako wynik.csv"

# Przetwarzanie z podglądem danych
dun "Pokaż podsumowanie danych z plików CSV w folderze raporty/"

Funkcje

Automatyczne wykrywanie i łączenie plików CSV
Obsługa różnych formatów plików (.csv, .CSV)
Automatyczne wykrywanie nagłówków kolumn
Obsługa dużych zbiorów danych
Szczegółowe logowanie działań

Konfiguracja

Użyj zmiennych środowiskowych, aby dostosować działanie:

export INPUT_DIR=moje_dane
export OUTPUT_FILE=wyniki/połączone_dane.csv

Więcej informacji

Zobacz pełną dokumentację przetwarzania CSV w pliku CSV_PROCESSOR.md.

📋 Wymagania

Docker & Docker Compose (opcjonalnie, tylko do uruchomienia z kontenera)
Python 3.11+
Poetry (zalecane) lub pip

🔧 Instalacja i uruchomienie

1. Instalacja z użyciem Poetry (zalecane)

# Klonowanie repozytorium
git clone <repository>
cd dun

# Instalacja zależności
poetry install

# Aktywacja środowiska wirtualnego
poetry shell

# Utworzenie przykładowych emaili (opcjonalne)
python setup_test_emails.py

2. Instalacja z użyciem pip

# Instalacja pakietu
pip install -e .

# lub dla instalacji globalnej
# pip install .

3. Uruchomienie (tryb interaktywny)

dun

4. Uruchomienie z Docker (opcjonalne)

# Zbuduj i uruchom wszystkie serwisy
docker-compose up --build

# Lub w tle
docker-compose up -d --build

4. Uruchomienie lokalne (opcjonalnie)

# Zainstaluj zależności
poetry install

# Uruchom główny skrypt
poetry run python dun.py

⚙️ Konfiguracja

Konfiguracja aplikacji odbywa się poprzez zmienne środowiskowe. Skopiuj plik .env.example do .env i dostosuj ustawienia:

cp .env.example .env

Główne ustawienia

Zmienna	Wartość domyślna	Opis
`APP_ENV`	`development`	Środowisko działania (development, testing, production)
`APP_DEBUG`	`true`	Tryb debugowania (true/false)
`LOG_LEVEL`	`INFO`	Poziom logowania (DEBUG, INFO, WARNING, ERROR, CRITICAL)
`LOG_FILE`	`logs/dun.log`	Ścieżka do pliku z logami

Konfiguracja IMAP

Zmienna	Wartość domyślna	Opis
`IMAP_ENABLED`	`true`	Włącza/wyłącza obsługę IMAP
`IMAP_SERVER`	`localhost`	Adres serwera IMAP
`IMAP_PORT`	`143`	Port serwera IMAP
`IMAP_USERNAME`	`testuser@example.com`	Nazwa użytkownika IMAP
`IMAP_PASSWORD`	`testpass123`	Hasło IMAP
`IMAP_USE_SSL`	`false`	Włącza szyfrowanie SSL
`IMAP_FOLDER`	`INBOX`	Domyślny folder pocztowy
`IMAP_TIMEOUT`	`30`	Limit czasu połączenia (w sekundach)
`IMAP_MARK_AS_READ`	`true`	Oznacz wiadomości jako przeczytane
`IMAP_DOWNLOAD_ATTACHMENTS`	`true`	Automatyczne pobieranie załączników

Konfiguracja Ollama (LLM)

Zmienna	Wartość domyślna	Opis
`OLLAMA_ENABLED`	`true`	Włącza/wyłącza integrację z Ollama
`OLLAMA_BASE_URL`	`http://localhost:11434`	Adres URL serwera Ollama
`OLLAMA_MODEL`	`mistral:7b`	Nazwa modelu językowego
`OLLAMA_TIMEOUT`	`120`	Limit czasu odpowiedzi (w sekundach)
`OLLAMA_MAX_TOKENS`	`2000`	Maksymalna liczba tokenów w odpowiedzi
`OLLAMA_TEMPERATURE`	`0.7`	Parametr kreatywności (0-1)
`OLLAMA_TOP_P`	`0.9`	Parametr różnorodności odpowiedzi

Ścieżki i katalogi

Zmienna	Wartość domyślna	Opis
`APP_DIR`	`/app`	Główny katalog aplikacji
`DATA_DIR`	`./data`	Katalog na dane
`OUTPUT_DIR`	`./output`	Katalog wyjściowy
`TEMP_DIR`	`./temp`	Katalog tymczasowy
`CACHE_DIR`	`./.cache`	Katalog na cache

Ustawienia wydajności

Zmienna	Wartość domyślna	Opis
`MAX_WORKERS`	`4`	Maksymalna liczba wątków roboczych
`TASK_TIMEOUT`	`300`	Limit czasu wykonania zadania (w sekundach)
`MAX_RETRIES`	`3`	Maksymalna liczba prób ponowienia
`RETRY_DELAY`	`5`	Opóźnienie między ponownymi próbami (w sekundach)

Bezpieczeństwo

Zmienna	Wartość domyślna	Opis
`ENABLE_RATE_LIMITING`	`true`	Włącza ograniczanie zapytań
`MAX_REQUESTS_PER_MINUTE`	`60`	Maksymalna liczba zapytań na minutę
`REQUIRE_AUTH`	`false`	Wymagaj uwierzytelniania
`AUTH_TOKEN`	-	Token uwierzytelniający

🏗️ Architektura

dun/
├── src/
│   ├── processor_engine.py    # Główny silnik procesora
│   └── llm_analyzer.py        # Analizator LLM
├── docker/
│   ├── dovecot.conf          # Konfiguracja serwera IMAP
│   ├── users                 # Dane użytkowników
│   └── mail/                 # Folder z wiadomościami
├── output/                   # Folder wynikowy
├── dun.py                    # Główny skrypt
├── .env                      # Konfiguracja
└── docker-compose.yml        # Definicja serwisów

📧 Przykładowe użycie

Po uruchomieniu systemu, procesor automatycznie:

Analizuje żądanie:

"Pobierz wszystkie wiadomości email ze skrzynki IMAP i zapisz je w folderach 
uporządkowanych według roku i miesiąca w formacie skrzynka/rok.miesiąc/*.eml"

Wykrywa wymagane biblioteki: imaplib, email
Instaluje biblioteki: Automatycznie instaluje wymagane pakiety
Łączy się z IMAP: Wykorzystuje dane z .env do połączenia
Pobiera emaile: Pobiera wszystkie wiadomości ze skrzynki

Organizuje pliki: Tworzy strukturę folderów:

output/
└── skrzynka/
    ├── 2024.11/
    │   ├── email_1.eml
    │   └── email_2.eml
    ├── 2024.12/
    │   └── email_3.eml
    └── 2025.06/
        ├── email_4.eml
        └── email_5.eml

🔧 Konfiguracja

Zmienne środowiskowe (.env)

# Konfiguracja IMAP
IMAP_SERVER=localhost          # Adres serwera IMAP
IMAP_PORT=143                  # Port IMAP
IMAP_USERNAME=testuser@example.com
IMAP_PASSWORD=testpass123
IMAP_USE_SSL=false            # Użycie SSL

# Ścieżki
OUTPUT_DIR=./output           # Folder wyjściowy

# Ollama
OLLAMA_BASE_URL=http://localhost:11434
OLLAMA_MODEL=mistral:7b

# Logowanie
LOG_LEVEL=INFO

Testowa skrzynka IMAP

Serwer: localhost:143
Użytkownik: testuser@example.com
Hasło: testpass123
Protokół: IMAP bez SSL

📝 Przykładowe żądania w języku naturalnym

System rozpoznaje różne typy żądań:

1. Pobieranie emaili

"Pobierz wszystkie wiadomości email ze skrzynki IMAP i zapisz je w folderach 
uporządkowanych według roku i miesiąca w formacie skrzynka/rok.miesiąc/*.eml"

2. Filtrowanie po dacie

"Pobierz emaile z ostatnich 30 dni i zapisz je w folderze recent_emails"

3. Filtrowanie po nadawcy

"Pobierz wszystkie emaile od sender@example.com i zapisz je w osobnym folderze"

4. Analiza załączników

"Pobierz emaile z załącznikami i wyodrębnij wszystkie pliki PDF do folderu attachments"

🔍 Monitorowanie

Logi systemu

# Podgląd logów Docker
docker-compose logs -f

# Logi konkretnego serwisu
docker-compose logs -f data-processor
docker-compose logs -f ollama
docker-compose logs -f mailserver

Sprawdzenie statusu Ollama

curl http://localhost:11434/api/tags

Testowanie IMAP

# Telnet do serwera IMAP
telnet localhost 143

# Przykładowe komendy IMAP
a1 LOGIN testuser@example.com testpass123
a2 SELECT INBOX
a3 SEARCH ALL
a4 LOGOUT

🧪 Rozwój i testowanie

Struktura projektu

# Dodawanie nowego procesora
class CustomProcessor:
    def setup(self):
        # Instaluj biblioteki
        pass
    
    def process(self, data):
        # Logika przetwarzania
        return result

Dodawanie nowych szablonów LLM

# W llm_analyzer.py
def _get_custom_processor(self) -> ProcessorConfig:
    code_template = '''
    # Twój kod tutaj
    result = {"status": "completed"}
    '''
    return ProcessorConfig(...)

🔧 Rozwiązywanie problemów

Ollama nie odpowiada

# Restart Ollama
docker-compose restart ollama

# Sprawdź czy model jest pobrany
docker-compose exec ollama ollama list

IMAP connection refused

# Sprawdź status serwera pocztowego
docker-compose restart mailserver

# Sprawdź logi
docker-compose logs mailserver

Błędy instalacji pakietów

# Wyczyść cache pip
docker-compose exec data-processor pip cache purge

# Restart kontenera
docker-compose restart data-processor

📊 Przykładowy wynik działania

{
    "status": "completed",
    "downloaded_files": [
        "output/skrzynka/2024.11/email_1.eml",
        "output/skrzynka/2024.12/email_2.eml", 
        "output/skrzynka/2025.06/email_3.eml"
    ],
    "total_count": 3,
    "folders_created": [
        "output/skrzynka/2024.11",
        "output/skrzynka/2024.12", 
        "output/skrzynka/2025.06"
    ]
}

🚀 Rozszerzenia

System może być rozszerzony o:

Więcej procesorów: CSV, JSON, XML, bazy danych
Różne protokoły: POP3, Exchange, SMTP
Chmura: Integracja z Gmail API, Outlook
Analiza treści: NLP, klasyfikacja, sentiment analysis
Automatyzacja: Cron jobs, watchdog, webhooks

🧪 Testowanie

Projekt zawiera kompleksowe testy jednostkowe i integracyjne. Aby uruchomić testy:

# Zainstaluj zależności developerskie
poetry install --with dev

# Uruchom testy
poetry run pytest tests/

# Z pokryciem kodu (wymaga pytest-cov)
poetry run pytest --cov=dun tests/

# Generuj raport HTML z pokryciem
poetry run pytest --cov=dun --cov-report=html tests/

Struktura testów

tests/unit/ - Testy jednostkowe poszczególnych komponentów
tests/integration/ - Testy integracyjne sprawdzające współdziałanie komponentów
tests/conftest.py - Konfiguracja i wspólne fikstury

📄 Licencja

Apache License - zobacz plik LICENSE

FilesExpand file tree

README.md

Latest commit

History