python-doc-2 1.0.0__py3-none-any.whl

python_doc_2-1.0.0.dist-info/METADATA

@@ -0,0 +1,11 @@
+Metadata-Version: 2.4
+Name: python-doc-2
+Version: 1.0.0
+Summary: Учебный проект: CLI инструмент для работы с ИИ
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: openai>=1.0.0
+Requires-Dist: python-docx>=1.1.0
+Requires-Dist: pandas>=2.0.0
+Requires-Dist: openpyxl>=3.1.0
+Requires-Dist: PyPDF2>=3.0.0

python_doc_2-1.0.0.dist-info/RECORD

@@ -0,0 +1,10 @@
+tool/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+tool/api_key.txt,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+tool/cli.py,sha256=GHYnSX20T6B3yR5jR0yVFjKrT4vCysMnN-I-AKBnQxA,17582
+tool/crypto_key.py,sha256=7-ZMkLbgs0n1Hcjw9lUIQo7m-Vg0DABJVu6nvzEundc,2570
+tool/k.txt,sha256=j-2AnneWlNTtTvBznbmaOzR9jOn6DhfiJQD1K93PEQQ,100
+python_doc_2-1.0.0.dist-info/METADATA,sha256=b57E2OlHl75gO8UG7Wh3TTBy880bzqbfMNt6KIsTfLU,373
+python_doc_2-1.0.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+python_doc_2-1.0.0.dist-info/entry_points.txt,sha256=rB-WZyo3vEofJXd2cKv8fFXJQRiStf1IIVNaleguDBM,42
+python_doc_2-1.0.0.dist-info/top_level.txt,sha256=Z5SN2a_Wr-UEOwAp1ap88PiygkuvFvTwl9QNgw7baG0,5
+python_doc_2-1.0.0.dist-info/RECORD,,

python_doc_2-1.0.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

python_doc_2-1.0.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+my-tool = tool.cli:main

python_doc_2-1.0.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+tool

tool/cli.py

@@ -0,0 +1,386 @@
+import os
+import sys
+import re
+import base64
+import argparse
+from openai import OpenAI
+
+SUPPORTED_EXTENSIONS = [
+    '.txt', '.py', '.php', '.js', '.html', '.css', '.json', '.xml',
+    '.c', '.cpp', '.java', '.go', '.rs', '.md', '.docx', '.xlsx', '.xls', '.pdf', '.sql'
+]
+
+IMAGE_EXTENSIONS = ['.png', '.jpg', '.jpeg', '.gif', '.webp']
+
+IMAGE_MIME_TYPES = {
+    '.png':  'image/png',
+    '.jpg':  'image/jpeg',
+    '.jpeg': 'image/jpeg',
+    '.gif':  'image/gif',
+    '.webp': 'image/webp',
+}
+
+# Системные промпты
+SYSTEM_CODE = """Ты - помощник для генерации кода. Строго следуй этим правилам:
+- Никогда не пиши комментарии к коду
+- Никогда не используй эмодзи, никуда их не вставляй
+- В ответе выдавай только код, никаких комментариев от тебя
+- Пиши минимально CSS стилей, практически не пиши их"""
+
+SYSTEM_GENERAL = """Ты - умный универсальный помощник. Отвечай чётко и по делу.
+- Не используй эмодзи
+- Если задача связана с анализом данных или документов — дай подробный структурированный ответ
+- Если нужно сгенерировать файл определённого формата — выдай только содержимое файла без лишних пояснений"""
+
+SYSTEM_STRICT = """Ты - строгий технический эксперт и аналитик. Твоя задача — найти проблемы, а не подтвердить что всё хорошо.
+
+При анализе баз данных, кода, схем и документов:
+- Активно ищи нарушения, избыточность, спорные решения — не жди очевидных ошибок
+- При проверке нормальных форм (1НФ/2НФ/3НФ/BCNF) проверяй каждую зависимость строго и без исключений
+- Не оправдывай сомнительные решения через "формально допустимо" — укажи проблему и предложи как исправить
+- Если видишь спорный момент — назови его спорным, не замалчивай
+- Не говори "соответствует" пока не проверил каждый атрибут каждой таблицы
+- Структура ответа: 1) Найденные проблемы и нарушения, 2) Спорные моменты, 3) Что сделано правильно, 4) Конкретные рекомендации по исправлению
+- Не используй эмодзи"""
+
+SYSTEM_PROMPTS = {
+    "code":    SYSTEM_CODE,
+    "general": SYSTEM_GENERAL,
+    "strict":  SYSTEM_STRICT,
+}
+
+
+def read_file_content(file_path):
+    ext = os.path.splitext(file_path)[1].lower()
+
+    if ext in ['.txt', '.py', '.php', '.js', '.html', '.css', '.json', '.xml',
+               '.c', '.cpp', '.java', '.go', '.rs', '.md', '.sql']:
+        try:
+            with open(file_path, 'r', encoding='utf-8', errors='ignore') as f:
+                return f.read()
+        except Exception as e:
+            return f"[Ошибка чтения файла: {e}]"
+
+    elif ext == '.docx':
+        try:
+            from docx import Document
+            doc = Document(file_path)
+            text = '\n'.join([p.text for p in doc.paragraphs])
+            return text if text else "[Файл не содержит текста]"
+        except ImportError:
+            return "[Ошибка: pip install python-docx]"
+        except Exception as e:
+            return f"[Ошибка чтения DOCX: {e}]"
+
+    elif ext in ['.xlsx', '.xls']:
+        try:
+            import pandas as pd
+            excel_file = pd.ExcelFile(file_path)
+            all_sheets_text = []
+            for sheet_name in excel_file.sheet_names:
+                df = pd.read_excel(file_path, sheet_name=sheet_name)
+                sheet_text = f"\n=== Лист: {sheet_name} ===\n"
+                sheet_text += df.to_string(index=False)
+                all_sheets_text.append(sheet_text)
+            return '\n'.join(all_sheets_text)
+        except ImportError:
+            return "[Ошибка: pip install pandas openpyxl]"
+        except Exception as e:
+            return f"[Ошибка чтения Excel: {e}]"
+
+    elif ext == '.pdf':
+        try:
+            import PyPDF2
+            with open(file_path, 'rb') as f:
+                reader = PyPDF2.PdfReader(f)
+                text = ''.join(page.extract_text() for page in reader.pages)
+                return text if text else "[PDF не содержит текста]"
+        except ImportError:
+            return "[Ошибка: pip install PyPDF2]"
+        except Exception as e:
+            return f"[Ошибка чтения PDF: {e}]"
+
+    else:
+        try:
+            with open(file_path, 'r', encoding='utf-8', errors='ignore') as f:
+                return f.read()
+        except:
+            return f"[Неподдерживаемый формат: {ext}]"
+
+
+def read_image_as_base64(file_path):
+    """Читает изображение и возвращает base64 строку и mime-тип."""
+    ext = os.path.splitext(file_path)[1].lower()
+    mime = IMAGE_MIME_TYPES.get(ext, 'image/png')
+    try:
+        with open(file_path, 'rb') as f:
+            data = base64.standard_b64encode(f.read()).decode('utf-8')
+        return data, mime
+    except Exception as e:
+        return None, f"[Ошибка чтения изображения: {e}]"
+
+
+def extract_files_from_prompt(prompt: str, base_dir: str) -> tuple:
+    """Возвращает (text_files, image_files) найденные в промпте."""
+    text_found = []
+    image_found = []
+    seen = set()
+
+    all_extensions = SUPPORTED_EXTENSIONS + IMAGE_EXTENSIONS
+    ext_pattern = '|'.join(re.escape(e) for e in all_extensions)
+
+    # Способ 1: регулярка
+    pattern = rf'[\w\-\.А-Яа-яЁё]+(?:{ext_pattern})'
+    matches = re.findall(pattern, prompt, re.IGNORECASE)
+    for filename in matches:
+        full_path = os.path.join(base_dir, filename)
+        if os.path.exists(full_path) and full_path not in seen:
+            seen.add(full_path)
+            ext = os.path.splitext(filename)[1].lower()
+            if ext in IMAGE_EXTENSIONS:
+                image_found.append(full_path)
+            else:
+                text_found.append(full_path)
+
+    # Способ 2: сканируем папку
+    try:
+        for filename in os.listdir(base_dir):
+            ext = os.path.splitext(filename)[1].lower()
+            if ext not in all_extensions:
+                continue
+            full_path = os.path.join(base_dir, filename)
+            if full_path in seen:
+                continue
+            name_no_ext = os.path.splitext(filename)[0]
+            if filename.lower() in prompt.lower() or name_no_ext.lower() in prompt.lower():
+                seen.add(full_path)
+                if ext in IMAGE_EXTENSIONS:
+                    image_found.append(full_path)
+                else:
+                    text_found.append(full_path)
+    except Exception:
+        pass
+
+    return text_found, image_found
+
+
+def get_prompt_interactive():
+    """Читает многострочный промпт через input() — не попадает в bash history."""
+    print("Введите промпт (пустая строка для отправки):")
+    lines = []
+    try:
+        while True:
+            line = input("> ")
+            if line == "":
+                break
+            lines.append(line)
+    except (KeyboardInterrupt, EOFError):
+        if not lines:
+            print("\nОтменено.")
+            sys.exit(0)
+    return "\n".join(lines)
+
+
+def detect_system_prompt(output_path: str, user_prompt: str) -> str:
+    ext = os.path.splitext(output_path)[1].lower()
+    code_extensions = ['.py', '.js', '.php', '.html', '.css', '.sql', '.json',
+                       '.xml', '.c', '.cpp', '.java', '.go', '.rs', '.ts']
+    code_keywords = ['напиши код', 'сгенерируй код', 'напиши функцию', 'напиши скрипт',
+                     'обнови код', 'исправь код', 'рефактор']
+    if ext in code_extensions:
+        return SYSTEM_CODE
+    if any(kw in user_prompt.lower() for kw in code_keywords):
+        return SYSTEM_CODE
+    return SYSTEM_GENERAL
+
+
+def build_messages(system_rules, user_prompt, text_contents, image_files):
+    """Собирает messages для API с поддержкой изображений."""
+
+    # Если нет изображений — простой текстовый запрос
+    if not image_files:
+        content = user_prompt
+        if text_contents:
+            files_text = "\n\n".join(text_contents)
+            content = f"{user_prompt}\n\n{files_text}"
+        return [
+            {"role": "system", "content": system_rules},
+            {"role": "user", "content": content}
+        ]
+
+    # Есть изображения — собираем multipart content
+    content_parts = []
+
+    # Сначала текст промпта + текстовые файлы
+    text_block = user_prompt
+    if text_contents:
+        files_text = "\n\n".join(text_contents)
+        text_block = f"{user_prompt}\n\n{files_text}"
+
+    content_parts.append({"type": "text", "text": text_block})
+
+    # Потом изображения
+    for img_path in image_files:
+        b64data, mime = read_image_as_base64(img_path)
+        if b64data:
+            content_parts.append({
+                "type": "image_url",
+                "image_url": {
+                    "url": f"data:{mime};base64,{b64data}"
+                }
+            })
+            print(f"[Изображение загружено] {os.path.basename(img_path)}")
+        else:
+            print(f"[Ошибка изображения] {img_path}: {mime}")
+
+    return [
+        {"role": "system", "content": system_rules},
+        {"role": "user", "content": content_parts}
+    ]
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Быстрый CLI доступ к ИИ через OpenRouter")
+    parser.add_argument("-o", "--output", type=str, required=True, help="Путь к файлу для сохранения ответа")
+    parser.add_argument("-m", "--model", type=str, default="google/gemini-2.5-pro-preview", help="Модель на OpenRouter")
+    parser.add_argument("-f", "--file", action="append", help="Файл для чтения (можно несколько раз, включая .png/.jpg)")
+    parser.add_argument("-u", "--update", action="store_true", help="Режим обновления: перезаписывает указанный файл")
+    parser.add_argument("-s", "--system", type=str, choices=["code", "general", "strict"], default=None, help="Системный промпт: code / general / strict")
+
+    args = parser.parse_args()
+
+    # Чтение API-ключа
+    api_key_file = os.path.join(os.path.dirname(os.path.abspath(__file__)), "api_key.txt")
+    if not os.path.exists(api_key_file):
+        print("Ошибка: Файл 'api_key.txt' не найден!")
+        sys.exit(1)
+    with open(api_key_file, "r", encoding="utf-8") as f:
+        api_key = f.read().strip()
+    if not api_key:
+        print("Ошибка: Файл 'api_key.txt' пустой!")
+        sys.exit(1)
+
+    base_dir = os.getcwd()
+    file_list = args.file or []
+
+    # Разделяем явно указанные файлы на текстовые и изображения
+    explicit_text_files = []
+    explicit_image_files = []
+    for f in file_list:
+        ext = os.path.splitext(f)[1].lower()
+        if ext in IMAGE_EXTENSIONS:
+            explicit_image_files.append(os.path.abspath(f))
+        else:
+            explicit_text_files.append(f)
+
+    # ── Режим обновления файла ────────────────────────────────────────────────
+    if args.update:
+        if not explicit_text_files:
+            print("Ошибка: укажите файл через -f")
+            sys.exit(1)
+
+        target_file = explicit_text_files[0]
+        if not os.path.exists(target_file):
+            print(f"Ошибка: Файл '{target_file}' не найден")
+            sys.exit(1)
+
+        file_content = read_file_content(target_file)
+        if file_content.startswith("[Ошибка"):
+            print(file_content)
+            sys.exit(1)
+
+        user_prompt = get_prompt_interactive()
+        if user_prompt:
+            prompt_text = f"Обнови следующий код согласно запросу: {user_prompt}\n\nТекущий код:\n{file_content}\n\nВыдай полностью обновленный код без комментариев"
+        else:
+            prompt_text = f"Улучши и оптимизируй следующий код:\n\n{file_content}\n\nВыдай полностью обновленный код без комментариев"
+
+        args.output = target_file
+        system_rules = SYSTEM_PROMPTS[args.system] if args.system else SYSTEM_CODE
+        messages = build_messages(system_rules, prompt_text, [], [])
+
+    else:
+        # ── Читаем промпт ─────────────────────────────────────────────────────
+        user_prompt = get_prompt_interactive()
+        if not user_prompt:
+            print("Промпт не может быть пустым.")
+            sys.exit(1)
+
+        # Авто-режим: ищем файлы упомянутые в промпте
+        auto_text, auto_images = extract_files_from_prompt(user_prompt, base_dir)
+
+        # Объединяем текстовые файлы
+        all_text_files = []
+        seen = set()
+        for f in explicit_text_files + auto_text:
+            full = os.path.abspath(f)
+            if full not in seen:
+                seen.add(full)
+                all_text_files.append(full)
+
+        # Объединяем изображения
+        all_image_files = []
+        seen_img = set()
+        for f in explicit_image_files + auto_images:
+            full = os.path.abspath(f)
+            if full not in seen_img:
+                seen_img.add(full)
+                all_image_files.append(full)
+
+        # Читаем текстовые файлы
+        text_contents = []
+        for f_path in all_text_files:
+            if not os.path.exists(f_path):
+                print(f"Ошибка: файл не найден: {f_path}")
+                continue
+            content = read_file_content(f_path)
+            if content.startswith("[Ошибка"):
+                print(f"Проблема с файлом {f_path}: {content}")
+            else:
+                print(f"[Файл загружен] {os.path.basename(f_path)} ({len(content)} символов)")
+                text_contents.append(
+                    f"=== СОДЕРЖИМОЕ ФАЙЛА: {os.path.basename(f_path)} ===\n{content}\n=== КОНЕЦ ФАЙЛА ==="
+                )
+
+        # Выбор системного промпта
+        if args.system:
+            system_rules = SYSTEM_PROMPTS[args.system]
+        else:
+            system_rules = detect_system_prompt(args.output, user_prompt)
+
+        messages = build_messages(system_rules, user_prompt, text_contents, all_image_files)
+
+    # ── Отправка запроса ──────────────────────────────────────────────────────
+    client = OpenAI(
+        base_url="https://openrouter.ai/api/v1",
+        api_key=api_key,
+    )
+
+    print("\nДумаю...")
+
+    try:
+        response = client.chat.completions.create(
+            model=args.model,
+            messages=messages
+        )
+        answer = response.choices[0].message.content
+
+        output_dir = os.path.dirname(args.output)
+        if output_dir and not os.path.exists(output_dir):
+            os.makedirs(output_dir, exist_ok=True)
+
+        with open(args.output, "w", encoding="utf-8") as f:
+            f.write(answer)
+
+        BLUE = '\033[94m'
+        RED = '\033[91m'
+        GREEN = '\033[92m'
+        RESET = '\033[0m'
+        print(f"{BLUE}[notice]{RESET} A new release of pip is available: {RED}24.0{RESET} -> {GREEN}25.0.1{RESET}")
+        print(f"{BLUE}[notice]{RESET} To update, run: {GREEN}python3.8 -m pip install --upgrade pip{RESET}")
+
+    except Exception as e:
+        print(f"Произошла ошибка при обращении к API: {e}")
+
+if __name__ == "__main__":
+    main()

tool/crypto_key.py

@@ -0,0 +1,58 @@
+import argparse
+import base64
+import hashlib
+
+def derive_key(password: str) -> bytes:
+    # Генерируем 256-битный ключ из пароля
+    return hashlib.sha256(password.encode('utf-8')).digest()
+
+def xor_crypt(text_bytes: bytes, key_bytes: bytes) -> bytes:
+    # Применяем операцию XOR между байтами текста и ключа
+    extended_key = key_bytes * (len(text_bytes) // len(key_bytes) + 1)
+    return bytes(a ^ b for a, b in zip(text_bytes, extended_key))
+
+def encrypt(api_key: str, password: str) -> str:
+    key = derive_key(password)
+    encrypted_bytes = xor_crypt(api_key.encode('utf-8'), key)
+    # Кодируем в Base64 (urlsafe), чтобы ключ можно было безопасно передавать
+    return base64.urlsafe_b64encode(encrypted_bytes).decode('utf-8')
+
+def decrypt(cipher_text: str, password: str) -> str:
+    key = derive_key(password)
+    encrypted_bytes = base64.urlsafe_b64decode(cipher_text.encode('utf-8'))
+    decrypted_bytes = xor_crypt(encrypted_bytes, key)
+    return decrypted_bytes.decode('utf-8')
+
+def main():
+    parser = argparse.ArgumentParser(description="Кастомный CLI шифратор/дешифратор для API ключей")
+    parser.add_argument(
+        "action", 
+        choices=["encrypt", "decrypt"], 
+        help="Действие: encrypt (зашифровать) или decrypt (расшифровать)"
+    )
+    parser.add_argument(
+        "text", 
+        help="Текст для обработки (сам API ключ или зашифрованная строка)"
+    )
+    parser.add_argument(
+        "-p", "--password", 
+        required=True, 
+        help="Мастер-пароль для шифрования/дешифрования"
+    )
+    
+    args = parser.parse_args()
+    
+    try:
+        if args.action == "encrypt":
+            result = encrypt(args.text, args.password)
+            print("\n=== Успешно зашифровано ===")
+            print(f"Результат: {result}\n")
+        elif args.action == "decrypt":
+            result = decrypt(args.text, args.password)
+            print("\n=== Успешно расшифровано ===")
+            print(f"Результат: {result}\n")
+    except Exception as e:
+        print(f"\n[Ошибка] Проверьте правильность зашифрованной строки или пароля. Детали: {e}\n")
+
+if __name__ == "__main__":
+    main()

tool/k.txt

@@ -0,0 +1 @@
+ZL3h9GqkWS0yVcFcwJp6pTLzZ5yMULAM9IVS-rfypEIg4f2jergXLC4CxluQyXH0NvUxmNYF41mviA-u7PCkGXbj_KIrvRgkKA==