gutarik 0.1.0__tar.gz

gutarik-0.1.0/PKG-INFO

@@ -0,0 +1,26 @@
+Metadata-Version: 2.4
+Name: gutarik
+Version: 0.1.0
+Summary: Auto .md docs generator
+License: MIT
+Keywords: Backend,Documentation,Docs,Docstring,Generator,Python,Markdown
+Author: ProudRykar
+Author-email: proudrykar@mail.ru
+Requires-Python: >=3.10
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Provides-Extra: yaml-toml
+Requires-Dist: pyyaml (>=6.0.2) ; extra == "yaml-toml"
+Requires-Dist: toml (>=0.10.2,<0.11.0) ; extra == "yaml-toml"
+Project-URL: Changelog, https://github.com/ProudRykar/GUTARIK/releases
+Project-URL: Issues, https://github.com/ProudRykar/GUTARIK/issues
+Project-URL: Repository, https://github.com/ProudRykar/GUTARIK
+Description-Content-Type: text/markdown
+
+# GUTARIK
+

gutarik-0.1.0/README.md

@@ -0,0 +1 @@
+# GUTARIK

gutarik-0.1.0/gutarik/config_loader.py

@@ -0,0 +1,249 @@
+"""Модуль для чтения конфигурационных файлов."""
+
+# Config loader
+import importlib
+import sys
+from pathlib import Path
+from typing import Any, Dict, Union, List
+
+GENERIC_POINTER = "gutarik"
+
+
+def __yaml_config_parser__(path: str, pointer: str = GENERIC_POINTER) -> Dict[str, Any]:
+    """Приватный метод для парсинга YML/YAML конфигурации.
+
+    Args:
+        path (str): Путь к файлу gutarik.yml или gutarik.yaml.
+        pointer (str): Указатель на раздел конфигурации для чтения.
+
+    Raises:
+        ImportError: Если PyYAML не установлен.
+        FileNotFoundError: Если файл не найден.
+        ValueError: Если YAML некорректен или имя файла не начинается с 'gutarik'.
+
+    Returns:
+        Dict[str, Any]: Словарь с параметрами конфигурации.
+    """
+    try:
+        import yaml  # type: ignore
+    except ImportError:
+        raise ImportError(
+            "To parse YAML/YML configuration files, you need to install PyYAML: "
+            "`pip install pyyaml` or `poetry add pyyaml`"
+        )
+
+    path_obj = Path(path)
+    if path_obj.name.split(".")[0] != "gutarik":
+        raise ValueError(f"Config file must start with 'gutarik', got: {path_obj.name}")
+
+    try:
+        with open(path_obj, "r", encoding="utf-8") as file:
+            config = yaml.safe_load(file)
+        return config.get(pointer, {}) if config else {}
+    except FileNotFoundError:
+        raise FileNotFoundError(f"YAML config file not found at: {path}")
+    except yaml.YAMLError as e:
+        raise ValueError(f"Error parsing YAML file: {e}")
+
+
+def __toml_config_parser__(path: str, pointer: str = GENERIC_POINTER) -> Dict[str, Any]:
+    """Приватный метод для парсинга TOML конфигурации.
+
+    Args:
+        path (str): Путь к файлу gutarik.toml или pyproject.toml.
+        pointer (str): Указатель на раздел конфигурации для чтения.
+
+    Raises:
+        ImportError: Если toml не установлен (для Python < 3.11).
+        FileNotFoundError: Если файл не найден.
+        ValueError: Если TOML некорректен или имя файла не начинается с 'gutarik'
+                    (кроме pyproject.toml).
+
+    Returns:
+        Dict[str, Any]: Словарь с параметрами конфигурации.
+    """
+    if sys.version_info >= (3, 11):
+        import tomllib as toml
+    else:
+        try:
+            import toml
+        except ImportError:
+            raise ImportError(
+                "To parse TOML configuration files, you need to install toml: "
+                "`pip install toml` or `poetry add toml`"
+            )
+
+    path_obj = Path(path)
+    if path_obj.name != "pyproject.toml" and path_obj.name.split(".")[0] != "gutarik":
+        raise ValueError(
+            f"Config file must start with 'gutarik' or be 'pyproject.toml', got: {path_obj.name}"
+        )
+
+    try:
+        with open(path_obj, "rb") as file:
+            config = toml.load(file)
+        if path_obj.name == "pyproject.toml":
+            return config.get("tool", {}).get(pointer, {})
+        return config.get(pointer, {}) if config else {}
+    except FileNotFoundError:
+        raise FileNotFoundError(f"TOML config file not found at: {path}")
+    except toml.TOMLDecodeError as e:
+        raise ValueError(f"Error parsing TOML file: {e}")
+
+
+def __python_config_parser__(
+    path: str, pointer: str = GENERIC_POINTER
+) -> Dict[str, Any]:
+    """Приватный метод для парсинга конфигурации на Python.
+
+    Args:
+        path (str): Путь к файлу gutarik.py.
+        pointer (str): Указатель на раздел конфигурации (игнорируется для Python файлов).
+
+    Raises:
+        FileNotFoundError: Если файл не найден.
+        ValueError: Если имя файла не начинается с 'gutarik' или модуль не может быть загружен.
+
+    Returns:
+        Dict[str, Any]: Словарь с параметрами конфигурации.
+    """
+    path_obj = Path(path)
+    if path_obj.name.split(".")[0] != "gutarik":
+        raise ValueError(f"Config file must start with 'gutarik', got: {path_obj.name}")
+
+    try:
+        module_name = path_obj.stem
+        spec = importlib.util.spec_from_file_location(module_name, path_obj)  # type: ignore
+        if spec is None or spec.loader is None:
+            raise ValueError(f"Failed to load module from {path_obj}")
+
+        module = importlib.util.module_from_spec(spec)  # type: ignore
+        sys.modules[module_name] = module
+        spec.loader.exec_module(module)
+
+        config = {
+            key: value
+            for key, value in module.__dict__.items()
+            if not key.startswith("_") and not callable(value)
+        }
+        return config.get(pointer, {}) if pointer in config else config
+    except FileNotFoundError:
+        raise FileNotFoundError(f"Python config file not found at: {path}")
+    except Exception as e:
+        raise ValueError(f"Error loading Python config: {e}")
+
+
+def __config_maker__(
+    config: Union[str, Dict[str, Any]], pointer: str = GENERIC_POINTER
+) -> Dict[str, Any]:
+    """Базовый парсер конфигурации.
+
+    Args:
+        config (Union[str, Dict[str, Any]]): Словарь конфигурации или путь к файлу gutarik.* или pyproject.toml.
+        pointer (str): Указатель на раздел конфигурации для чтения.
+
+    Raises:
+        ValueError: Если формат файла не поддерживается или имя файла не начинается с 'gutarik'
+                    (кроме pyproject.toml).
+
+    Returns:
+        Dict[str, Any]: Распарсенная конфигурация.
+    """
+    if isinstance(config, dict):
+        return config.get(pointer, {}) if pointer else config
+
+    if isinstance(config, str):
+        path_obj = Path(config)
+        ext = path_obj.suffix.lower()
+        if ext in (".yml", ".yaml"):
+            return __yaml_config_parser__(config, pointer)
+        elif ext == ".toml":
+            return __toml_config_parser__(config, pointer)
+        elif ext == ".py":
+            return __python_config_parser__(config, pointer)
+        else:
+            raise ValueError("Only YML/YAML, TOML, or Python configs are supported!")
+
+    raise TypeError("Config must be a string (file path) or dictionary")
+
+
+def load_config(
+    config: Union[str, Dict[str, Any], None] = None, pointer: str = GENERIC_POINTER
+) -> Dict[str, Any]:
+    """Загружает конфигурацию из файла, имя которого начинается с 'gutarik' (.yml, .yaml, .toml, .py) или из pyproject.toml.
+
+    Args:
+        config (Union[str, Dict[str, Any], None]): Словарь конфигурации или путь к файлу конфигурации.
+            Если None, выполняется поиск pyproject.toml или gutarik.* в текущей директории.
+        pointer (str): Указатель на раздел конфигурации для чтения.
+
+    Returns:
+        Dict[str, Any]: Словарь с параметрами конфигурации.
+
+    Raises:
+        ValueError: Если конфигурационный файл не найден, найдено несколько файлов или формат не поддерживается.
+    """
+    supported_extensions = {".yml", ".yaml", ".toml", ".py"}
+
+    if isinstance(config, dict):
+        return __config_maker__(config, pointer)
+
+    if config:
+        config_path = Path(config)
+        if not config_path.exists():
+            raise ValueError(f"Config file {config_path} does not exist")
+        return __config_maker__(str(config_path), pointer)
+
+    pyproject_path = Path.cwd() / "pyproject.toml"
+    if pyproject_path.exists():
+        try:
+            config = __toml_config_parser__(str(pyproject_path), pointer)
+            if config:
+                return config
+        except ValueError:
+            pass
+
+    config_files: List[Path] = []
+    for ext in supported_extensions:
+        config_files.extend(Path.cwd().glob(f"gutarik{ext}"))
+
+    if not config_files:
+        print(
+            "No config file with name 'gutarik.*' or '[tool.gutarik]' in pyproject.toml found, using default configuration"
+        )
+        return {
+            "PROJECT_DIRS": [Path("gutarik/src")],
+            "DOCS_DIR": Path("docs"),
+            "SUPPORTED_EXT": [".py"],
+            "WIKI_REPO": "https://github.com/user/repo.wiki.git",
+            "LOCAL_WIKI_DIR": Path("wiki_tmp"),
+            "EXCLUDE_DIRS": [],
+        }
+    if len(config_files) > 1:
+        raise ValueError(
+            f"Multiple config files found: {config_files}. Specify one file."
+        )
+
+    return __config_maker__(str(config_files[0]), pointer)
+
+
+def validate_config(config: Dict[str, Any]) -> None:
+    """Проверяет наличие обязательных ключей конфигурации.
+
+    Args:
+        config (Dict[str, Any]): Словарь конфигурации.
+
+    Raises:
+        ValueError: Если обязательные ключи отсутствуют.
+    """
+    required_keys = {
+        "project_dirs",
+        "docs_dir",
+        "supported_ext",
+        "wiki_repo",
+        "local_wiki_dir",
+        "exclude_dirs",
+    }
+    missing_keys = required_keys - set(config.keys())
+    if missing_keys:
+        raise ValueError(f"Missing required configuration keys: {missing_keys}")

gutarik-0.1.0/gutarik/generate_docs.py

@@ -0,0 +1,444 @@
+"""Модуль для генерации Markdown-документации."""
+# GenerateDocs
+
+import argparse
+from pathlib import Path
+from typing import Any
+import ast
+import os
+import re
+import shutil
+import subprocess
+
+from gutarik.config_loader import load_config, validate_config
+
+config = load_config(os.getenv("gutarik_config"), pointer="gutarik")
+validate_config(config)
+
+PROJECT_DIRS = [Path(p) for p in config["project_dirs"]]
+DOCS_DIR = Path(config["docs_dir"])
+SUPPORTED_EXT = config["supported_ext"]
+WIKI_REPO = config["wiki_repo"]
+LOCAL_WIKI_DIR = Path(config["local_wiki_dir"])
+EXCLUDE_DIRS = [Path(p) for p in config["exclude_dirs"]]
+
+
+def parse_google_docstring(docstring: str) -> dict[str, Any]:
+    """Парсит Google-style докстринг в структуру словаря.
+
+    Args:
+        docstring (str): Исходный докстринг функции, метода или класса.
+
+    Returns:
+        dict: Словарь с ключами:
+            - first_line (str): Первая строка описания.
+            - rest_description (str): Основное описание.
+            - args (str): Раздел аргументов.
+            - returns (str): Раздел возвращаемых значений.
+            - raises (str): Раздел исключений.
+    """
+    if not docstring:
+        return {
+            "first_line": "",
+            "rest_description": "",
+            "args": "",
+            "returns": "",
+            "raises": "",
+        }
+
+    sections: dict[str, Any] = {
+        "first_line": "",
+        "rest_description": [],
+        "args": [],
+        "returns": [],
+        "raises": [],
+    }
+    current_section = "description"
+    is_first_line = True
+
+    for line in docstring.splitlines():
+        line_strip = line.strip()
+        if re.match(r"^(Args|Attributes):", line_strip):
+            current_section = "args"
+        elif re.match(r"^Returns:", line_strip):
+            current_section = "returns"
+        elif re.match(r"^(Raises|Exceptions):", line_strip):
+            current_section = "raises"
+        else:
+            if current_section == "description":
+                if is_first_line and line_strip:
+                    sections["first_line"] = line_strip
+                    is_first_line = False
+                else:
+                    if isinstance(sections["rest_description"], list):
+                        sections["rest_description"].append(line)
+            else:
+                if isinstance(sections[current_section], list):
+                    sections[current_section].append(line)
+
+    for key in sections:
+        if key == "first_line":
+            continue
+        sections[key] = "\n".join(sections[key]).strip()
+    return sections
+
+
+def extract_docstrings(file_path: Path) -> dict[Any, Any]:
+    """Извлекает докстринги и тела функций/методов из Python-файла.
+
+    Args:
+        file_path (Path): Путь к Python-файлу.
+
+    Returns:
+        dict: Структура с докстрингами и кодом:
+            - module (str): Докстринг модуля.
+            - classes (dict): Классы и их методы.
+            - functions (dict): Глобальные функции.
+    """
+    with open(file_path, encoding="utf-8") as f:
+        tree = ast.parse(f.read(), filename=str(file_path))
+
+    docstrings: dict[str, Any] = {
+        "module": ast.get_docstring(tree),
+        "classes": {},
+    }
+
+    for node in tree.body:
+        if isinstance(node, ast.ClassDef):
+            class_doc: dict[str, Any] = parse_google_docstring(
+                ast.get_docstring(node) or ""
+            )
+            class_doc["methods"] = {}
+            for cnode in node.body:
+                if isinstance(cnode, (ast.FunctionDef, ast.AsyncFunctionDef)):
+                    method_doc = parse_google_docstring(ast.get_docstring(cnode) or "")
+                    method_doc["body"] = get_function_body(file_path, cnode)
+                    class_doc["methods"][cnode.name] = method_doc
+            docstrings["classes"][node.name] = class_doc
+        elif isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef)):
+            func_doc = parse_google_docstring(ast.get_docstring(node) or "")
+            func_doc["body"] = get_function_body(file_path, node)
+            docstrings.setdefault("functions", {})[node.name] = func_doc
+
+    return docstrings
+
+
+def get_function_body(
+    file_path: Path, node: ast.FunctionDef | ast.AsyncFunctionDef
+) -> str:
+    """Извлекает полный исходный код функции или метода, включая сигнатуру и декораторы.
+
+    Args:
+        file_path (Path): Путь к файлу с исходным кодом.
+        node (ast.AST): AST-узел функции или метода.
+
+    Returns:
+        str: Текст исходного кода функции.
+    """
+    with open(file_path, encoding="utf-8") as f:
+        lines = f.readlines()
+
+    start_line = node.lineno - 1
+    if hasattr(node, "decorator_list") and node.decorator_list:
+        decorator_start = min(decorator.lineno - 1 for decorator in node.decorator_list)
+        start_line = decorator_start
+        while start_line > 0 and lines[start_line - 1].strip().startswith("@"):
+            start_line -= 1
+
+    end_line: int = node.end_lineno or start_line + 1
+
+    while end_line < len(lines):
+        line = lines[end_line].strip()
+        if line and line.startswith("@"):
+            break
+        if line and not line.startswith(" "):
+            break
+        end_line += 1
+
+    body = "".join(lines[start_line:end_line]).rstrip()
+    return body
+
+
+def format_function_md(name: str, doc: dict[str, Any], is_method: bool = False) -> str:
+    """Форматирует функцию или метод в Markdown с таблицами аргументов, возвращаемых значений и исключений.
+
+    Args:
+        name (str): Имя функции или метода.
+        doc (dict): Докстринг функции, разобранный через parse_google_docstring.
+        is_method (bool): Флаг, указывающий, что это метод класса.
+
+    Returns:
+        str: Сформатированный Markdown.
+    """
+    display_name = name.replace("__init__", "init")
+    is_async = doc["body"].strip().startswith("async def")
+    prefix = "async def" if is_async else "def"
+    md = [f"## {prefix} {display_name}:"]
+
+    if doc["first_line"]:
+        md.append(f"#### {doc['first_line']}")
+
+    if doc["rest_description"]:
+        md.append(doc["rest_description"])
+
+    # HTTP route
+    if "@" in doc["body"]:
+        route_lines: list[str] = []
+        current_route: list[str] = []
+        for line in doc["body"].splitlines():
+            line_strip = line.strip()
+            if line_strip.startswith(("@get", "@post", "@put", "@delete")) or (
+                current_route and line_strip
+            ):
+                current_route.append(line_strip)
+                if line_strip.endswith(")"):
+                    route_lines.append(" ".join(current_route))
+                    current_route = []
+        if route_lines:
+            md.append("#### Маршруты:")
+            for route in route_lines:
+                md.append(f"- `{route}`")
+
+    # Аргументы
+    if doc["args"]:
+        md.append("\n#### Аргументы")
+        md.append("| Аргумент | Тип | Описание |")
+        md.append("|----------|-----|----------|")
+        for arg in doc["args"].split("\n"):
+            if arg.strip():
+                parts = arg.strip().split(":", 1)
+                if len(parts) == 2:
+                    name_type = parts[0].strip()
+                    desc = parts[1].strip()
+                    if "(" in name_type and ")" in name_type:
+                        arg_name = name_type.split("(")[0].strip()
+                        arg_type = name_type.split("(")[1].replace(")", "").strip()
+                    else:
+                        arg_name = name_type
+                        arg_type = ""
+                    md.append(f"| `{arg_name}` | `{arg_type}` | {desc} |")
+                else:
+                    md.append(f"| `{arg.strip()}` | | |")
+
+    # Возвращаемое значение
+    if doc["returns"] and doc["returns"].strip().lower() != "none":
+        md.append("\n#### Возвращает")
+        md.append("| Тип | Описание |")
+        md.append("|-----|----------|")
+        for ret in doc["returns"].split("\n"):
+            if ret.strip():
+                parts = ret.strip().split(":", 1)
+                if len(parts) == 2:
+                    ret_type = parts[0].strip()
+                    ret_desc = parts[1].strip()
+                    md.append(f"| `{ret_type}` | {ret_desc} |")
+                else:
+                    md.append(f"| `{ret.strip()}` | |")
+
+    # Исключения
+    if doc["raises"]:
+        md.append("\n#### Исключения")
+        md.append("| Исключение | Описание |")
+        md.append("|------------|----------|")
+        for exc in doc["raises"].split("\n"):
+            if exc.strip():
+                parts = exc.strip().split(":", 1)
+                if len(parts) == 2:
+                    exc_type = parts[0].strip()
+                    exc_desc = parts[1].strip()
+                    md.append(f"| `{exc_type}` | {exc_desc} |")
+                else:
+                    md.append(f"| `{exc.strip()}` | |")
+
+    md.append("\n```python")
+    md.append(doc["body"])
+    md.append("```")
+
+    return "\n".join(md)
+
+
+def write_md(file_path: Path, docstrings: dict[str, Any]) -> str:
+    """Генерирует Markdown-файл для модуля или класса.
+
+    Args:
+        file_path (Path): Путь к Python-файлу.
+        docstrings (dict): Словарь с докстрингами, полученный через extract_docstrings.
+
+    Returns:
+        str: Полный Markdown контент для файла.
+    """
+    md_content = []
+
+    if docstrings.get("module"):
+        md_content.append(f"# Модуль {file_path.stem}\n\n{docstrings['module']}\n")
+
+    for cls_name, cls_doc in docstrings.get("classes", {}).items():
+        md_content.append(f"## Класс {cls_name}\n")
+        if cls_doc.get("first_line"):
+            md_content.append(f"**{cls_doc['first_line']}**")
+        if cls_doc.get("rest_description"):
+            md_content.append(cls_doc["rest_description"])
+        if cls_doc.get("args"):
+            md_content.append("\n**Args:**")
+            for arg in cls_doc["args"].split("\n"):
+                if arg.strip():
+                    parts = arg.strip().split(":", 1)
+                    if len(parts) == 2:
+                        arg_name_type = parts[0].strip()
+                        arg_desc = parts[1].strip()
+                        md_content.append(f"- `{arg_name_type}`: {arg_desc}")
+                    else:
+                        md_content.append(f"- `{arg.strip()}`")
+        if cls_doc.get("methods"):
+            md_content.append("\n---")
+        for method_name, method_doc in cls_doc.get("methods", {}).items():
+            md_content.append(
+                format_function_md(method_name, method_doc, is_method=True)
+            )
+            md_content.append("---")
+
+    for func_name, func_doc in docstrings.get("functions", {}).items():
+        md_content.append(format_function_md(func_name, func_doc))
+        md_content.append("---")
+
+    return "\n".join(md_content)
+
+
+def create_docs(src_dirs: list[Path], dst_dir: Path, exclude_dirs: list[Path]) -> None:
+    """Создает Markdown-документацию для всех Python-файлов из списка директорий.
+
+    Args:
+        src_dirs (list[Path]): Список исходных директорий.
+        dst_dir (Path): Папка, куда будут сохранены сгенерированные Markdown-файлы.
+    """
+    for src_dir in src_dirs:
+        for root, dirs, files in os.walk(src_dir):
+            # Пропускаем исключённые директории
+            dirs[:] = [d for d in dirs if Path(root) / d not in exclude_dirs]
+            rel_path = Path(root).relative_to(src_dir)
+            target_dir = dst_dir / rel_path
+            target_dir.mkdir(parents=True, exist_ok=True)
+
+            for file in files:
+                file_path = Path(root) / file
+                if (
+                    file_path.suffix in SUPPORTED_EXT
+                    and file_path.name != "__init__.py"
+                ):
+                    docstrings = extract_docstrings(file_path)
+                    md_content = write_md(file_path, docstrings)
+                    md_file = target_dir / f"{file_path.stem}.md"
+                    with open(md_file, "w", encoding="utf-8") as f:
+                        f.write(md_content)
+
+
+def rename_wiki_files_by_header(local_wiki_dir: Path, docs_dir: Path) -> None:
+    """Переименовывает .md файлы в .wiki_tmp на основании второй строки исходных .py файлов.
+
+    Если вторая строка файла начинается с # , используется её содержимое (без решётки и пробелов) как новое имя Markdown-файла.
+    Если такого заголовка нет, имя остаётся прежним.
+
+    Args:
+        local_wiki_dir (Path): Локальная директория Wiki (.wiki_tmp)
+        docs_dir (Path): Папка с документацией (docs/)
+    """
+    for root, _, files in os.walk(local_wiki_dir):
+        for file in files:
+            if not file.endswith(".md"):
+                continue
+
+            md_path = Path(root) / file
+            rel_path = md_path.relative_to(local_wiki_dir)
+            py_source = docs_dir / rel_path
+            py_source = py_source.with_suffix(".py")
+
+            if not py_source.exists():
+                for src_dir in PROJECT_DIRS:
+                    possible_py = src_dir / rel_path
+                    possible_py = possible_py.with_suffix(".py")
+                    if possible_py.exists():
+                        py_source = possible_py
+                        break
+
+            if not py_source.exists():
+                continue
+
+            try:
+                with open(py_source, encoding="utf-8") as f:
+                    lines = f.readlines()
+                if len(lines) < 2:
+                    continue
+                second_line = lines[1].strip()
+                if second_line.startswith("# "):
+                    new_name = second_line[2:].strip()
+                    if not new_name:
+                        continue
+                    new_md_name = f"{new_name}.md"
+                    new_md_path = md_path.with_name(new_md_name)
+                    if new_md_path != md_path:
+                        os.rename(md_path, new_md_path)
+                        print(f"[Wiki] Переименован: {md_path.name} → {new_md_name}")
+            except Exception as e:
+                print(f"[Wiki] Ошибка при обработке {md_path}: {e}")
+
+
+def push_to_wiki(docs_dir: Path) -> None:
+    """Копирует Markdown-документы в локальный клон Wiki и пушит изменения в удаленный репозиторий.
+
+    Args:
+        docs_dir (Path): Папка с сгенерированной документацией.
+    """
+    if not LOCAL_WIKI_DIR.exists():
+        subprocess.run(["git", "clone", WIKI_REPO, str(LOCAL_WIKI_DIR)], check=True)
+
+    for root, _, files in os.walk(docs_dir):
+        rel_path = Path(root).relative_to(docs_dir)
+        target_dir = LOCAL_WIKI_DIR / rel_path
+        target_dir.mkdir(parents=True, exist_ok=True)
+        for file in files:
+            if file.endswith(".md"):
+                src_file = Path(root) / file
+                dst_file = target_dir / file
+                shutil.copy2(src_file, dst_file)
+
+    rename_wiki_files_by_header(LOCAL_WIKI_DIR, docs_dir)
+
+    subprocess.run(["git", "-C", str(LOCAL_WIKI_DIR), "add", "."], check=True)
+    status = subprocess.run(
+        ["git", "-C", str(LOCAL_WIKI_DIR), "status", "--porcelain"],
+        capture_output=True,
+        text=True,
+        check=True,
+    )
+    if status.stdout.strip():
+        subprocess.run(
+            [
+                "git",
+                "-C",
+                str(LOCAL_WIKI_DIR),
+                "commit",
+                "-m",
+                "[Wiki] Обновление документации",
+            ],
+            check=True,
+        )
+        subprocess.run(["git", "-C", str(LOCAL_WIKI_DIR), "push"], check=True)
+        print("[Wiki] Документация успешно обновлена и отправлена в Wiki.")
+    else:
+        print("[Wiki] Нет изменений для коммита.")
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Генерация документации проекта")
+    parser.add_argument(
+        "--push",
+        action="store_true",
+        help="Если указан, пушить документацию в GitHub Wiki",
+    )
+    args = parser.parse_args()
+
+    create_docs(PROJECT_DIRS, DOCS_DIR, EXCLUDE_DIRS)
+    print(f"Документация сгенерирована в {DOCS_DIR}")
+
+    if args.push:
+        push_to_wiki(DOCS_DIR)

gutarik-0.1.0/gutarik/validate_config.py

@@ -0,0 +1,115 @@
+"""Модуль для валидации конфигураций."""
+
+# Validate
+from pathlib import Path
+import re
+from typing import List, Optional
+from urllib.parse import urlparse
+from gutarik.config_loader import validate_config as validate_config_keys
+
+
+def validate_path(path: Path) -> None:
+    """Проверяет, что путь безопасен и корректен.
+
+    Args:
+        path (Path): Путь для проверки.
+    """
+    if not re.match(r"^[a-zA-Z0-9_/.-]+$", str(path)):
+        raise ValueError(f"Небезопасный путь: {path}")
+    if path.exists() and not path.is_dir():
+        raise ValueError(f"Путь {path} не является директорией")
+
+
+def validate_project_dirs(dirs: List[Path]) -> None:
+    """Проверяет список директорий проекта.
+
+    Args:
+        dirs (List[Path]): Список директорий проекта.
+    """
+    for dir_path in dirs:
+        validate_path(dir_path)
+        if not dir_path.exists():
+            raise ValueError(f"Директория {dir_path} не существует")
+
+
+def validate_exclude_dirs(dirs: List[Path]) -> None:
+    """Проверяет список исключаемых директорий.
+
+    Args:
+        dirs (List[Path]): Список исключаемых директорий.
+    """
+    if not isinstance(dirs, list):
+        raise ValueError("EXCLUDE_DIRS должен быть списком")
+    for dir_path in dirs:
+        if not isinstance(dir_path, (str, Path)):
+            raise ValueError(f"Некорректный путь в EXCLUDE_DIRS: {dir_path}")
+        validate_path(Path(dir_path))
+
+
+def validate_docs_dir(docs_dir: Path) -> None:
+    """Проверяет директорию для документации.
+
+    Args:
+        docs_dir (Path): Директория для документации.
+    """
+    validate_path(docs_dir)
+    try:
+        docs_dir.mkdir(parents=True, exist_ok=True)
+    except Exception as e:
+        raise ValueError(f"Не удалось создать директорию {docs_dir}: {e}")
+
+
+def validate_supported_ext(extensions: List[str]) -> None:
+    """Проверяет список поддерживаемых расширений.
+
+    Args:
+        extensions (List[str]): Список расширений.
+    """
+    for ext in extensions:
+        if not isinstance(ext, str) or not ext.startswith("."):
+            raise ValueError(f"Некорректное расширение: {ext}")
+
+
+def validate_wiki_repo(url: str) -> None:
+    """Проверяет URL репозитория Wiki.
+
+    Args:
+        url (str): URL репозитория Wiki.
+    """
+    try:
+        parsed = urlparse(url)
+        if parsed.scheme not in ("https", "http"):
+            raise ValueError(f"URL {url} должен использовать схему http или https")
+        if not parsed.netloc or not parsed.path:
+            raise ValueError(f"Некорректный URL репозитория: {url}")
+        if not parsed.netloc.endswith("github.com") or not url.endswith(".wiki.git"):
+            raise ValueError(f"URL {url} не является валидным GitHub Wiki URL")
+    except Exception as e:
+        raise ValueError(f"Ошибка валидации URL {url}: {e}")
+
+
+def validate_config(config: dict, config_path: Optional[str | Path] = None) -> None:
+    """Проверяет все конфигурационные переменные.
+
+    Args:
+        config (dict): Конфигурационный словарь.
+        config_path (str | Path, optional): Путь к конфигурационному файлу. Defaults to None.
+    """
+    if config_path:
+        config_path = Path(config_path)
+        if (
+            config_path.name != "pyproject.toml"
+            and config_path.name.split(".")[0] != "gutarik"
+        ):
+            raise ValueError(
+                f"Файл конфигурации должен начинаться с 'gutarik' или быть 'pyproject.toml', получено: {config_path.name}"
+            )
+        if config_path.suffix.lower() not in {".yml", ".yaml", ".toml", ".py"}:
+            raise ValueError(f"Формат {config_path.suffix} не поддерживается")
+    validate_config_keys(config)
+    validate_project_dirs([Path(p) for p in config["project_dirs"]])
+    validate_docs_dir(Path(config["docs_dir"]))
+    validate_supported_ext(config["supported_ext"])
+    validate_wiki_repo(config["wiki_repo"])
+    validate_path(Path(config["local_wiki_dir"]))
+    validate_exclude_dirs([Path(p) for p in config["exclude_dirs"]])

gutarik-0.1.0/pyproject.toml

@@ -0,0 +1,35 @@
+[tool.poetry]
+name = "gutarik"
+version = "0.1.0"
+description = "Auto .md docs generator"
+authors = ["ProudRykar <proudrykar@mail.ru>"]
+license = "MIT"
+readme = "README.md"
+keywords = ["Backend","Documentation","Docs","Docstring","Generator","Python","Markdown"]
+packages = [{include = "gutarik"}]
+
+[tool.poetry.urls]
+Repository = "https://github.com/ProudRykar/GUTARIK"
+Issues = "https://github.com/ProudRykar/GUTARIK/issues"
+Changelog = "https://github.com/ProudRykar/GUTARIK/releases"
+
+[tool.poetry.dependencies]
+python = ">=3.10"
+pyyaml = {version = ">=6.0.2", optional = true}
+toml = {version = "^0.10.2", optional = true}
+
+[tool.poetry.group.dev.dependencies]
+ruff = ">=0.14.0"
+mypy = ">=1.15.0"
+pre-commit = ">=4.1.0"
+pytest = "^8.4.2"
+
+[tool.poetry.group.docs.dependencies]
+mkdocs = ">=1.6.1"
+mkdocs-material = ">=9.6.19"
+
+[tool.poetry.extras]
+yaml_toml = ["pyyaml", "toml"]
+
+[tool.poetry.scripts]
+gutarik = "gutarik.generate_docs:main"