evopy

evopy - Ewolucyjny Asystent dla konwersji text2python

Evopy to kompleksowy, ale minimalny system asystenta, który jest w stanie ewoluować z prostego skryptu konsolowego do pełnego środowiska z wieloma piaskownicami Docker. Asystent wspiera konwersję tekstu na kod Python i zarządzanie projektami w kontenerach Docker.

Dokumentacja

Sekcja Opis
📊 Raporty testów Raporty porównawcze modeli LLM
🧪 Instrukcja testowania Dokumentacja systemu testowego
🏗️ Architektura piaskownic Opis architektury piaskownic Docker
💻 Umiejętności programistyczne Lista umiejętności junior programisty
📝 Wytyczne projektu Wytyczne rozwoju projektu
🖥️ Wsparcie cross-platform Informacje o wsparciu dla różnych systemów
📊 Testy diagramów Mermaid Przykłady diagramów Mermaid

📚 Pełna dokumentacja online

Funkcjonalności

Architektura

System został zaprojektowany w oparciu o architekturę ewolucyjną, która rozwija się w miarę użytkowania:

Diagram ewolucji asystenta

flowchart TB
    subgraph "Faza 1: Start"
        SinglePython["Pojedynczy skrypt Python"] --> |"Instalacja i sprawdzenie zależności"| ModelInit["Inicjalizacja modelu DeepSeek w Ollama"]
    end
    
    subgraph "Faza 2: Rozwój podstawowych funkcji"
        ModelInit --> |"Interakcja z użytkownikiem"| ConversationManagement["Zarządzanie konwersacjami (historia, wątki)"]
        ConversationManagement --> |"Wykrywanie wzorców w odpowiedziach modelu"| CodeExtraction["Ekstrakcja i zarządzanie kodem (Python, YAML)"]
    end
    
    subgraph "Faza 3: Integracja z Dockerem"
        CodeExtraction --> |"Generowanie plików Docker Compose"| DockerProjects["Zarządzanie projektami Docker Compose"]
        DockerProjects --> |"Uruchamianie i zarządzanie kontenerami"| SandboxEnvironments["Środowiska piaskownicowe dla projektów"]
    end
    
    subgraph "Faza 4: Automatyzacja i ewolucja"
        SandboxEnvironments --> |"Uczenie się na podstawie interakcji z użytkownikiem"| SkillAcquisition["Nabywanie nowych umiejętności"]
        SkillAcquisition --> |"Rozbudowa infrastruktury"| MultipleSandboxes["Wiele niezależnych piaskownic dla różnych wątków konwersacji"]
        MultipleSandboxes --> |"Integracja z zewnętrznymi API"| APIIntegration["Integracja z zewnętrznymi usługami i API"]
    end
    
    SinglePython -.-> SkillAcquisition
    
    classDef phase1 fill:#f9f9f9,stroke:#333,stroke-width:1px,color:#111
    classDef phase2 fill:#e3f2fd,stroke:#1976d2,stroke-width:1px,color:#111
    classDef phase3 fill:#e8f5e9,stroke:#388e3c,stroke-width:1px,color:#111
    classDef phase4 fill:#fff8e1,stroke:#ffa000,stroke-width:1px,color:#111

Struktura projektu

evopy/
├── main.py                # Główny punkt wejścia do aplikacji
├── text2python.py         # Moduł konwersji tekstu na kod Python
├── python2text.py         # Moduł konwersji kodu Python na opis tekstowy
├── docker_sandbox.py      # Moduł zarządzania piaskownicami Docker
├── dependency_manager.py  # Moduł zarządzania zależnościami i auto-naprawy importów
├── decision_tree.py       # Moduł drzewa decyzyjnego do śledzenia procesu myślowego
├── test.sh                # Skrypt testowy dla pojedynczego modelu
├── report.sh              # Skrypt generujący raporty porównawcze dla wielu modeli
├── modules/               # Moduły funkcjonalne
│   ├── text2python/       # Moduł konwersji tekstu na kod Python
│   │   ├── __init__.py
│   │   ├── text2python.py
│   │   └── config.py
│   └── python2text/       # Moduł konwersji kodu Python na opis tekstowy
│       ├── __init__.py
│       ├── python2text.py
│       └── config.py
├── tests/                 # Testy
│   ├── correctness/       # Testy poprawności
│   │   ├── correctness_test.py
│   │   └── results/
│   └── performance/       # Testy wydajności
│       ├── performance_test.py
│       └── results/
├── reports/               # Raporty porównawcze modeli
├── test_results/          # Wyniki testów
├── generated_code/        # Wygenerowany kod
├── docker/                # Pliki konfiguracyjne Docker
│   ├── Dockerfile
│   └── docker-compose.yml
├── config/                # Pliki konfiguracyjne
│   └── .env               # Zmienne środowiskowe
├── docs/                  # Dokumentacja
│   ├── project_guidelines.md          # Wytyczne projektu
│   ├── junior_programmer_skills.md    # Umiejętności junior programisty
│   ├── sandbox_architecture.md        # Architektura piaskownic
│   └── TESTING.md                     # Dokumentacja systemu testowego
├── .venv/                 # Wirtualne środowisko Python
└── README.md              # Ten plik

Funkcje i komponenty

Konwersja tekst-na-kod

  1. Analiza zapytania użytkownika - przetwarzanie zapytania w języku naturalnym
  2. Generowanie kodu Python - tworzenie kodu realizującego zapytanie
  3. Weryfikacja intencji - sprawdzanie, czy kod realizuje intencje użytkownika
  4. Analiza logiczna - wykrywanie potencjalnych problemów w kodzie
  5. Wykonanie kodu - uruchomienie kodu w bezpiecznym środowisku
  6. Autonaprawa zależności - automatyczne wykrywanie i naprawianie brakujących importów

Zarządzanie projektami Docker

  1. Tworzenie projektów - generowanie plików Docker Compose
  2. Zarządzanie kontenerami - uruchamianie, zatrzymywanie i monitorowanie kontenerów
  3. Izolacja środowiska - bezpieczne wykonywanie kodu w izolowanych kontenerach
  4. Współdzielenie danych - wymiana danych między kontenerami a hostem
  5. Zarządzanie zależnościami - automatyczne instalowanie wymaganych pakietów

Testowanie i optymalizacja

  1. Framework testowy umożliwia ocenę wydajności asystenta na różnych zadaniach programistycznych
  2. Testy podstawowe sprawdzają umiejętności junior programisty (algorytmy, struktury danych, OOP)
  3. Testy złożonych zadań weryfikują zdolność asystenta do rozwiązywania rzeczywistych problemów
  4. Analiza architektury porównuje różne podejścia do generowania i wykonywania kodu
  5. Raporty z testów pomagają zidentyfikować obszary do optymalizacji i ulepszeń
  6. Automatyczne testy zapytań weryfikują poprawność konwersji tekst-na-kod i analizę logiczną

System testowania i raportowania modeli LLM

Evopy zawiera zaawansowany system testowania i porównywania różnych modeli LLM:

Przykładowe użycie:

# Generowanie pełnego raportu porównawczego
./report.sh

# Porównanie tylko wybranych modeli
./report.sh --compare=llama,bielik --format=html

# Analiza trendów z ostatnich 60 dni
./report.sh --trend=60 --only-report

Szczegółowa dokumentacja systemu testowego znajduje się w pliku docs/TESTING.md.

Specyfikacja systemu konwersji tekst-na-kod

System konwersji tekst-na-kod działa w następujących krokach:

1. Konwersja tekstu na kod Python

2. Weryfikacja intencji użytkownika

3. Analiza logiczna kodu

4. Autonaprawa zależności

Specyfikacja systemu piaskownic Docker

System piaskownic Docker zapewnia bezpieczne środowisko do wykonywania kodu:

1. Tworzenie piaskownicy

2. Wykonanie kodu

3. Zarządzanie zależnościami

Wymagania systemowe

Instalacja

Automatyczna instalacja

# Pobierz repozytorium
git clone https://github.com/tom-sapletta-com/evopy.git
cd evopy

# Uruchom skrypt instalacyjny
bash install.sh

Skrypt instalacyjny automatycznie:

  1. Sprawdzi wymagania systemowe
  2. Utworzy wirtualne środowisko Python
  3. Zainstaluje wymagane zależności Python
  4. Zainstaluje zależności systemowe do generowania raportów (pandoc, wkhtmltopdf)
  5. Sprawdzi dostępność Dockera i Ollama
  6. Skonfiguruje środowisko do pracy

Zależności do generowania raportów

Do generowania raportów w formatach HTML i PDF wymagane są następujące narzędzia:

Skrypt instalacyjny próbuje zainstalować te narzędzia automatycznie na systemach Linux. Na innych systemach operacyjnych wyświetla instrukcje instalacji.

Manualna instalacja

# Pobierz repozytorium
git clone https://github.com/tom-sapletta-com/evopy.git
cd evopy

# Utwórz wirtualne środowisko Python
python -m venv .venv
source .venv/bin/activate  # Linux/Mac
# lub
# .venv\Scripts\activate  # Windows

# Zainstaluj zależności
pip install -r requirements.txt

# Zainstaluj Ollama (jeśli nie jest zainstalowany)
# Instrukcje: https://github.com/ollama/ollama

# Pobierz model llama3
ollama pull llama3

Użycie

Podstawowe użycie

# Aktywuj wirtualne środowisko
source .venv/bin/activate  # Linux/Mac
# lub
# .venv\Scripts\activate  # Windows

# Uruchom asystenta
python main.py

Uruchamianie testów

# Uruchom testy dla pojedynczego modelu z interaktywnym wyborem
./test.sh

# Uruchom testy dla konkretnego modelu
./test.sh --model=llama

# Wygeneruj raport porównawczy dla wszystkich dostępnych modeli
./report.sh

Uruchamianie testów i raportów

# Testowanie pojedynczego modelu
bash test.sh --model=llama3

# Generowanie raportu porównawczego dla wszystkich modeli
bash report.sh

# Generowanie raportu z określonym formatem i okresem analizy trendów
python generate_report.py --format=all --trend=30

Parametry generowania raportów

Skrypt generate_report.py obsługuje następujące parametry:

Przykład:

python generate_report.py --format=html --trend=60 --output=./custom_reports

Tryb deweloperski

# Tworzenie środowiska deweloperskiego
conda env create -f environment.yml
conda activate evopy

# Instalacja w trybie deweloperskim
pip install -e .

Licencja

Ten projekt jest udostępniany na licencji Apache 2.0. Szczegóły w pliku LICENSE.

Autorzy

Podziękowania

This site is open source. Improve this page.