wrd 0.1.41__py3-none-any.whl → 1.0.2__py3-none-any.whl

dune/interactive_mapper.py

@@ -1,599 +0,0 @@
-"""
-Interaktywny mapper zadań do bibliotek z automatycznym odpytywaniem o dane wejściowe.
-"""
-
-import os
-import sys
-import subprocess
-import importlib
-import inspect
-import ast
-from typing import Dict, List, Any, Optional, Tuple
-from dataclasses import dataclass
-from pathlib import Path
-from loguru import logger
-import json
-
-
-@dataclass
-class LibraryInterface:
-    """Definicja interfejsu biblioteki."""
-    name: str
-    package: str
-    main_function: str
-    required_params: List[str]
-    optional_params: List[str]
-    param_types: Dict[str, str]
-    param_descriptions: Dict[str, str]
-    examples: List[Dict[str, Any]]
-    cli_interface: Optional[str] = None
-
-
-@dataclass
-class TaskMapping:
-    """Mapowanie zadania do bibliotek."""
-    task_keywords: List[str]
-    libraries: List[LibraryInterface]
-    priority: int = 1
-
-
-class InteractiveMapper:
-    """Interaktywny mapper zadań do bibliotek."""
-
-    def __init__(self):
-        self.library_database = self._build_library_database()
-        self.task_mappings = self._build_task_mappings()
-        self.discovered_interfaces = {}
-
-    def _build_library_database(self) -> Dict[str, LibraryInterface]:
-        """Buduje bazę danych dostępnych bibliotek i ich interfejsów."""
-
-        return {
-            # Email processing
-            "imaplib": LibraryInterface(
-                name="IMAP Email Client",
-                package="imaplib",
-                main_function="IMAP4_SSL",
-                required_params=["server", "username", "password"],
-                optional_params=["port", "use_ssl", "folder"],
-                param_types={
-                    "server": "str",
-                    "username": "str",
-                    "password": "str",
-                    "port": "int",
-                    "use_ssl": "bool",
-                    "folder": "str"
-                },
-                param_descriptions={
-                    "server": "Adres serwera IMAP (np. imap.gmail.com)",
-                    "username": "Nazwa użytkownika/email",
-                    "password": "Hasło do skrzynki",
-                    "port": "Port serwera (143 dla IMAP, 993 dla IMAPS)",
-                    "use_ssl": "Czy używać szyfrowania SSL",
-                    "folder": "Folder do przetwarzania (domyślnie INBOX)"
-                },
-                examples=[
-                    {
-                        "server": "imap.gmail.com",
-                        "username": "user@gmail.com",
-                        "password": "app_password",
-                        "port": 993,
-                        "use_ssl": True
-                    }
-                ]
-            ),
-
-            # Database access
-            "sqlalchemy": LibraryInterface(
-                name="SQL Database Access",
-                package="sqlalchemy",
-                main_function="create_engine",
-                required_params=["database_url"],
-                optional_params=["pool_size", "echo", "timeout"],
-                param_types={
-                    "database_url": "str",
-                    "pool_size": "int",
-                    "echo": "bool",
-                    "timeout": "int"
-                },
-                param_descriptions={
-                    "database_url": "URL połączenia z bazą danych (postgresql://user:pass@host/db)",
-                    "pool_size": "Rozmiar puli połączeń",
-                    "echo": "Czy logować zapytania SQL",
-                    "timeout": "Timeout połączenia w sekundach"
-                },
-                examples=[
-                    {
-                        "database_url": "postgresql://user:password@localhost:5432/mydb",
-                        "pool_size": 5,
-                        "echo": False
-                    },
-                    {
-                        "database_url": "sqlite:///data.db"
-                    }
-                ]
-            ),
-
-            # Web scraping
-            "requests": LibraryInterface(
-                name="HTTP Client",
-                package="requests",
-                main_function="get",
-                required_params=["url"],
-                optional_params=["headers", "timeout", "verify_ssl", "proxies"],
-                param_types={
-                    "url": "str",
-                    "headers": "dict",
-                    "timeout": "int",
-                    "verify_ssl": "bool",
-                    "proxies": "dict"
-                },
-                param_descriptions={
-                    "url": "URL do pobrania",
-                    "headers": "Nagłówki HTTP (jako słownik)",
-                    "timeout": "Timeout żądania w sekundach",
-                    "verify_ssl": "Czy weryfikować certyfikaty SSL",
-                    "proxies": "Konfiguracja proxy (jako słownik)"
-                },
-                examples=[
-                    {
-                        "url": "https://api.example.com/data",
-                        "headers": {"User-Agent": "Dune Bot 1.0"},
-                        "timeout": 30
-                    }
-                ]
-            ),
-
-            # File processing
-            "pandas": LibraryInterface(
-                name="Data Analysis",
-                package="pandas",
-                main_function="read_csv",
-                required_params=["filepath"],
-                optional_params=["separator", "encoding", "header_row"],
-                param_types={
-                    "filepath": "str",
-                    "separator": "str",
-                    "encoding": "str",
-                    "header_row": "int"
-                },
-                param_descriptions={
-                    "filepath": "Ścieżka do pliku CSV",
-                    "separator": "Separator kolumn (domyślnie ',')",
-                    "encoding": "Kodowanie pliku (np. utf-8, cp1250)",
-                    "header_row": "Numer wiersza z nagłówkami (0 = pierwszy wiersz)"
-                },
-                examples=[
-                    {
-                        "filepath": "data.csv",
-                        "separator": ",",
-                        "encoding": "utf-8"
-                    }
-                ]
-            ),
-
-            # Image processing
-            "pillow": LibraryInterface(
-                name="Image Processing",
-                package="Pillow",
-                main_function="Image.open",
-                required_params=["image_path"],
-                optional_params=["output_format", "quality", "resize_dimensions"],
-                param_types={
-                    "image_path": "str",
-                    "output_format": "str",
-                    "quality": "int",
-                    "resize_dimensions": "tuple"
-                },
-                param_descriptions={
-                    "image_path": "Ścieżka do pliku obrazu",
-                    "output_format": "Format wyjściowy (JPEG, PNG, WEBP)",
-                    "quality": "Jakość kompresji (1-100 dla JPEG)",
-                    "resize_dimensions": "Nowe wymiary jako (width, height)"
-                },
-                examples=[
-                    {
-                        "image_path": "input.jpg",
-                        "output_format": "JPEG",
-                        "quality": 85,
-                        "resize_dimensions": (800, 600)
-                    }
-                ]
-            )
-        }
-
-    def _build_task_mappings(self) -> List[TaskMapping]:
-        """Buduje mapowania zadań do bibliotek."""
-
-        return [
-            TaskMapping(
-                task_keywords=["email", "imap", "pop3", "skrzynka", "wiadomość", "poczta"],
-                libraries=[self.library_database["imaplib"]],
-                priority=1
-            ),
-            TaskMapping(
-                task_keywords=["baza danych", "sql", "postgresql", "mysql", "sqlite"],
-                libraries=[self.library_database["sqlalchemy"]],
-                priority=1
-            ),
-            TaskMapping(
-                task_keywords=["http", "api", "rest", "pobierz", "strona", "url"],
-                libraries=[self.library_database["requests"]],
-                priority=1
-            ),
-            TaskMapping(
-                task_keywords=["csv", "excel", "pandas", "dataframe", "tabela", "dane"],
-                libraries=[self.library_database["pandas"]],
-                priority=1
-            ),
-            TaskMapping(
-                task_keywords=["obraz", "zdjęcie", "jpg", "png", "resize", "grafika"],
-                libraries=[self.library_database["pillow"]],
-                priority=1
-            )
-        ]
-
-    def analyze_task_and_map_libraries(self, natural_request: str) -> List[LibraryInterface]:
-        """Analizuje zadanie i mapuje je do odpowiednich bibliotek."""
-
-        logger.info("🔍 Analizowanie zadania i mapowanie bibliotek...")
-
-        request_lower = natural_request.lower()
-        matched_libraries = []
-
-        # Znajdź pasujące mapowania
-        for mapping in self.task_mappings:
-            score = sum(1 for keyword in mapping.task_keywords
-                        if keyword in request_lower)
-
-            if score > 0:
-                for library in mapping.libraries:
-                    if library not in matched_libraries:
-                        matched_libraries.append(library)
-                        logger.info(f"📚 Znaleziono bibliotekę: {library.name} (score: {score})")
-
-        # Sortuj według priorytetu
-        matched_libraries.sort(key=lambda x: self._get_library_priority(x.name), reverse=True)
-
-        return matched_libraries
-
-    def _get_library_priority(self, library_name: str) -> int:
-        """Zwraca priorytet biblioteki."""
-        priorities = {
-            "IMAP Email Client": 10,
-            "SQL Database Access": 9,
-            "HTTP Client": 8,
-            "Data Analysis": 7,
-            "Image Processing": 6
-        }
-        return priorities.get(library_name, 1)
-
-    def discover_cli_interface(self, package_name: str) -> Optional[Dict[str, Any]]:
-        """Odkrywa interfejs CLI biblioteki poprzez analizę kodu."""
-
-        if package_name in self.discovered_interfaces:
-            return self.discovered_interfaces[package_name]
-
-        logger.info(f"🔎 Odkrywanie interfejsu CLI dla {package_name}...")
-
-        try:
-            # Spróbuj zaimportować pakiet
-            module = importlib.import_module(package_name)
-
-            # Sprawdź czy ma CLI
-            cli_info = self._analyze_module_for_cli(module)
-
-            if cli_info:
-                self.discovered_interfaces[package_name] = cli_info
-                logger.success(f"✅ Odkryto interfejs CLI dla {package_name}")
-                return cli_info
-
-        except ImportError:
-            logger.warning(f"⚠️  Pakiet {package_name} nie jest zainstalowany")
-        except Exception as e:
-            logger.warning(f"⚠️  Błąd analizy {package_name}: {e}")
-
-        return None
-
-    def _analyze_module_for_cli(self, module) -> Optional[Dict[str, Any]]:
-        """Analizuje moduł w poszukiwaniu interfejsu CLI."""
-
-        cli_info = {
-            "has_cli": False,
-            "main_functions": [],
-            "cli_commands": [],
-            "parameters": []
-        }
-
-        # Sprawdź główne funkcje modułu
-        for name, obj in inspect.getmembers(module):
-            if inspect.isfunction(obj) and not name.startswith('_'):
-                sig = inspect.signature(obj)
-                params = []
-
-                for param_name, param in sig.parameters.items():
-                    param_info = {
-                        "name": param_name,
-                        "type": str(param.annotation) if param.annotation != param.empty else "Any",
-                        "default": param.default if param.default != param.empty else None,
-                        "required": param.default == param.empty
-                    }
-                    params.append(param_info)
-
-                cli_info["main_functions"].append({
-                    "name": name,
-                    "parameters": params,
-                    "docstring": obj.__doc__
-                })
-
-        if cli_info["main_functions"]:
-            cli_info["has_cli"] = True
-
-        return cli_info if cli_info["has_cli"] else None
-
-    def interactive_parameter_collection(self, library: LibraryInterface) -> Dict[str, Any]:
-        """Interaktywnie zbiera parametry dla biblioteki."""
-
-        logger.info(f"📝 Zbieranie parametrów dla: {library.name}")
-        print(f"\n🔧 KONFIGURACJA: {library.name}")
-        print("=" * 50)
-
-        if library.param_descriptions:
-            print("📋 Opis biblioteki:")
-            for param, desc in library.param_descriptions.items():
-                if param in library.required_params:
-                    print(f"   • {param} (wymagany): {desc}")
-                else:
-                    print(f"   • {param} (opcjonalny): {desc}")
-
-        # Pokaż przykłady
-        if library.examples:
-            print(f"\n💡 Przykład konfiguracji:")
-            example = library.examples[0]
-            for key, value in example.items():
-                print(f"   {key} = {value}")
-
-        print("\n" + "=" * 50)
-
-        collected_params = {}
-
-        # Zbierz wymagane parametry
-        for param in library.required_params:
-            collected_params[param] = self._collect_single_parameter(
-                param, library, required=True
-            )
-
-        # Zbierz opcjonalne parametry (zapytaj czy user chce)
-        if library.optional_params:
-            print(f"\n🔧 Parametry opcjonalne:")
-            for param in library.optional_params:
-                if self._ask_yes_no(f"Czy chcesz skonfigurować {param}?"):
-                    collected_params[param] = self._collect_single_parameter(
-                        param, library, required=False
-                    )
-
-        return collected_params
-
-    def _collect_single_parameter(self, param_name: str, library: LibraryInterface,
-                                  required: bool = True) -> Any:
-        """Zbiera pojedynczy parametr."""
-
-        # Sprawdź czy jest w zmiennych środowiskowych
-        env_variants = [
-            param_name.upper(),
-            f"{library.package.upper()}_{param_name.upper()}",
-            f"DUNE_{param_name.upper()}"
-        ]
-
-        env_value = None
-        env_source = None
-
-        for env_var in env_variants:
-            env_value = os.getenv(env_var)
-            if env_value:
-                env_source = env_var
-                break
-
-        # Przygotuj prompt
-        param_desc = library.param_descriptions.get(param_name, "")
-        param_type = library.param_types.get(param_name, "str")
-
-        prompt = f"📌 {param_name}"
-        if param_desc:
-            prompt += f" ({param_desc})"
-        if not required:
-            prompt += " [opcjonalny]"
-
-        if env_value:
-            prompt += f" [znaleziono w {env_source}: {env_value}]"
-            if self._ask_yes_no(f"Użyć wartości z {env_source}?", default=True):
-                return self._convert_type(env_value, param_type)
-
-        # Pobierz od użytkownika
-        while True:
-            try:
-                user_input = input(f"{prompt}: ").strip()
-
-                if not user_input and not required:
-                    return None
-
-                if not user_input and required:
-                    print("❌ Ten parametr jest wymagany!")
-                    continue
-
-                return self._convert_type(user_input, param_type)
-
-            except KeyboardInterrupt:
-                print("\n⚠️  Przerwano przez użytkownika")
-                sys.exit(1)
-            except Exception as e:
-                print(f"❌ Błąd: {e}. Spróbuj ponownie.")
-
-    def _convert_type(self, value: str, param_type: str) -> Any:
-        """Konwertuje wartość do odpowiedniego typu."""
-
-        if param_type == "int":
-            return int(value)
-        elif param_type == "bool":
-            return value.lower() in ["true", "1", "yes", "tak", "y"]
-        elif param_type == "float":
-            return float(value)
-        elif param_type == "list":
-            return value.split(",")
-        elif param_type == "dict":
-            return json.loads(value)
-        elif param_type == "tuple" and "," in value:
-            return tuple(map(int, value.split(",")))
-        else:
-            return value
-
-    def _ask_yes_no(self, question: str, default: bool = None) -> bool:
-        """Zadaje pytanie tak/nie."""
-
-        if default is True:
-            prompt = f"{question} [T/n]: "
-        elif default is False:
-            prompt = f"{question} [t/N]: "
-        else:
-            prompt = f"{question} [t/n]: "
-
-        while True:
-            try:
-                answer = input(prompt).strip().lower()
-
-                if not answer and default is not None:
-                    return default
-
-                if answer in ["t", "tak", "y", "yes", "1", "true"]:
-                    return True
-                elif answer in ["n", "nie", "no", "0", "false"]:
-                    return False
-                else:
-                    print("Odpowiedz 't' (tak) lub 'n' (nie)")
-
-            except KeyboardInterrupt:
-                print("\n⚠️  Przerwano przez użytkownika")
-                sys.exit(1)
-
-    def generate_runtime_config(self, libraries: List[LibraryInterface],
-                                collected_params: Dict[str, Dict[str, Any]]) -> Dict[str, Any]:
-        """Generuje konfigurację runtime na podstawie zebranych danych."""
-
-        # Zbierz wszystkie wymagane pakiety
-        packages = {"required": [], "optional": []}
-        env_vars = {"required": [], "optional": []}
-
-        for library in libraries:
-            packages["required"].append(library.package)
-
-            # Dodaj zmienne środowiskowe na podstawie parametrów
-            lib_params = collected_params.get(library.name, {})
-            for param_name, value in lib_params.items():
-                env_var = f"{library.package.upper()}_{param_name.upper()}"
-                if param_name in library.required_params:
-                    env_vars["required"].append(env_var)
-                else:
-                    env_vars["optional"].append(env_var)
-
-        # Usuń duplikaty
-        packages["required"] = list(set(packages["required"]))
-        packages["optional"] = list(set(packages["optional"]))
-        env_vars["required"] = list(set(env_vars["required"]))
-        env_vars["optional"] = list(set(env_vars["optional"]))
-
-        return {
-            "runtime": {
-                "type": "docker",
-                "base_image": "python:3.11-slim",
-                "python_packages": packages,
-                "environment": env_vars
-            },
-            "collected_parameters": collected_params
-        }
-
-    def save_parameters_to_env(self, collected_params: Dict[str, Dict[str, Any]],
-                               env_file: str = ".env") -> None:
-        """Zapisuje zebrane parametry do pliku .env."""
-
-        logger.info(f"💾 Zapisywanie parametrów do {env_file}")
-
-        # Wczytaj istniejący .env jeśli istnieje
-        existing_vars = {}
-        if os.path.exists(env_file):
-            with open(env_file, 'r') as f:
-                for line in f:
-                    line = line.strip()
-                    if '=' in line and not line.startswith('#'):
-                        key, value = line.split('=', 1)
-                        existing_vars[key] = value
-
-        # Dodaj nowe zmienne
-        new_vars = {}
-        for lib_name, params in collected_params.items():
-            for param_name, value in params.items():
-                if value is not None:
-                    # Kilka wariantów nazwy zmiennej
-                    env_var = f"DUNE_{param_name.upper()}"
-                    new_vars[env_var] = str(value)
-
-        # Połącz i zapisz
-        all_vars = {**existing_vars, **new_vars}
-
-        with open(env_file, 'w') as f:
-            f.write("# Dune Configuration\n")
-            f.write("# Auto-generated parameters\n\n")
-
-            for key, value in sorted(all_vars.items()):
-                f.write(f"{key}={value}\n")
-
-        logger.success(f"✅ Parametry zapisane do {env_file}")
-        print(f"\n💾 Zapisano {len(new_vars)} nowych parametrów do {env_file}")
-
-    def run_interactive_mapping(self, natural_request: str) -> Dict[str, Any]:
-        """Uruchamia pełny interaktywny proces mapowania."""
-
-        print("\n" + "=" * 60)
-        print("🤖 DUNE - INTERAKTYWNY MAPPER BIBLIOTEK")
-        print("=" * 60)
-        print(f"📝 Zadanie: {natural_request}")
-        print("=" * 60)
-
-        # 1. Mapuj biblioteki
-        libraries = self.analyze_task_and_map_libraries(natural_request)
-
-        if not libraries:
-            print("❌ Nie znaleziono pasujących bibliotek dla tego zadania")
-            return {}
-
-        print(f"\n📚 Znalezione biblioteki ({len(libraries)}):")
-        for i, lib in enumerate(libraries, 1):
-            print(f"   {i}. {lib.name} ({lib.package})")
-
-        # 2. Zbierz parametry dla każdej biblioteki
-        collected_params = {}
-
-        for library in libraries:
-            if self._ask_yes_no(f"\nKonfigurować {library.name}?", default=True):
-                params = self.interactive_parameter_collection(library)
-                collected_params[library.name] = params
-
-        # 3. Generuj konfigurację
-        runtime_config = self.generate_runtime_config(libraries, collected_params)
-
-        # 4. Zapisz do .env
-        if collected_params and self._ask_yes_no("\nZapisać parametry do .env?", default=True):
-            self.save_parameters_to_env(collected_params)
-
-        print("\n" + "=" * 60)
-        print("✅ MAPOWANIE ZAKOŃCZONE POMYŚLNIE!")
-        print("=" * 60)
-        print(f"📦 Pakiety do zainstalowania: {len(runtime_config['runtime']['python_packages']['required'])}")
-        print(f"🔧 Parametrów zebranych: {sum(len(params) for params in collected_params.values())}")
-        print("=" * 60)
-
-        return {
-            "libraries": libraries,
-            "parameters": collected_params,
-            "runtime_config": runtime_config,
-            "natural_request": natural_request
-        }