resparser.py

import json
import os
from collections import defaultdict
from typing import Dict, Union, Set, List, Any
import sys

def parse_json_schema(data: Any, path: str = "") -> Dict[str, Union[Set[str], dict]]:
    """
    Рекурсивно парсит JSON данные и строит схему ключей.
    """
    schema = defaultdict(set)
    
    if isinstance(data, dict):
        for key, value in data.items():
            new_path = f"{path}.{key}" if path else key
            if isinstance(value, (dict, list)):
                nested_schema = parse_json_schema(value, new_path)
                if key in schema:
                    if isinstance(schema[key], dict) and isinstance(nested_schema, dict):
                        schema[key] = merge_schemas(schema[key], nested_schema)
                    else:
                        schema[key].add(f"mixed_type: {type(value).__name__}")
                else:
                    schema[key] = nested_schema
            else:
                # Обработка случая, когда значение может быть разных типов
                if key in schema and next(iter(schema[key])) != type(value).__name__:
                    schema[key].add(type(value).__name__)
                else:
                    schema[key].add(type(value).__name__)
    elif isinstance(data, list):
        if data:  # Обрабатываем только непустые списки
            first_item = data[0]
            if isinstance(first_item, (dict, list)):
                for item in data:
                    nested_schema = parse_json_schema(item, path)
                    schema = merge_schemas(schema, nested_schema)
            else:
                types = {type(item).__name__ for item in data}
                if path:
                    schema[path].update(types)
    
    return dict(schema)

def merge_schemas(
    schema1: Dict[str, Union[Set[str], dict]], 
    schema2: Dict[str, Union[Set[str], dict]]
) -> Dict[str, Union[Set[str], dict]]:
    """
    Объединяет две схемы JSON.
    """
    merged = defaultdict(set)
    schema1 = defaultdict(set, schema1)
    schema2 = defaultdict(set, schema2)
    all_keys = set(schema1.keys()) | set(schema2.keys())
    
    for key in all_keys:
        if key in schema1 and key in schema2:
            val1, val2 = schema1[key], schema2[key]
            
            if isinstance(val1, dict) and isinstance(val2, dict):
                merged[key] = merge_schemas(val1, val2)
            elif isinstance(val1, set) and isinstance(val2, set):
                merged[key] = val1 | val2
            else:
                merged[key] = set()
                if isinstance(val1, dict):
                    merged[key].add("nested_dict")
                    merged[key].update(flatten_dict_types(val1))
                else:
                    merged[key].update(val1)
                if isinstance(val2, dict):
                    merged[key].add("nested_dict")
                    merged[key].update(flatten_dict_types(val2))
                else:
                    merged[key].update(val2)
                merged[key].add("mixed_type")
        elif key in schema1:
            merged[key] = schema1[key]
        else:
            merged[key] = schema2[key]
    
    return dict(merged)

def flatten_dict_types(d: dict) -> Set[str]:
    """
    Извлекает все типы из вложенного словаря.
    """
    types = set()
    for key, value in d.items():
        if isinstance(value, dict):
            types.add(f"dict:{key}")
            types.update(flatten_dict_types(value))
        else:
            types.update(value)
    return types

def save_schema_to_file(schema: dict, filename: str) -> None:
    """
    Сохраняет схему в текстовый файл.
    """
    output_filename = f"{os.path.splitext(filename)[0]}-структура.txt"
    
    with open(output_filename, 'w', encoding='utf-8') as f:
        def write_schema(schema: dict, indent: int = 0):
            for key, value in schema.items():
                if isinstance(value, dict):
                    f.write("  " * indent + f"{key}:\n")
                    write_schema(value, indent + 1)
                else:
                    types = ", ".join(sorted(value))
                    f.write("  " * indent + f"- {key} ({types})\n")
        
        write_schema(schema)
    print(f"Схема сохранена в файл: {output_filename}")

def process_json_file(filename: str) -> None:
    """
    Обрабатывает один JSON файл.
    """
    try:
        with open(filename, 'r', encoding='utf-8') as f:
            data = json.load(f)
        
        schema = parse_json_schema(data)
        save_schema_to_file(schema, filename)
        
    except json.JSONDecodeError as e:
        print(f"Ошибка в файле {filename}: некорректный JSON - {e}", file=sys.stderr)
    except Exception as e:
        print(f"Ошибка при обработке файла {filename}: {e}", file=sys.stderr)
        raise  # Добавляем raise для диагностики

def main() -> None:
    """
    Основная функция: находит все JSON файлы в текущей директории и обрабатывает их.
    """
    json_files = [f for f in os.listdir() if f.lower().endswith('.json')]
    
    if not json_files:
        print("В текущей директории не найдено JSON файлов.", file=sys.stderr)
        return
    
    print(f"Найдено JSON файлов для обработки: {len(json_files)}")
    
    for json_file in json_files:
        print(f"\nОбработка файла: {json_file}")
        process_json_file(json_file)

if __name__ == "__main__":
    try:
        main()
    except Exception as e:
        print(f"Критическая ошибка: {e}", file=sys.stderr)
        sys.exit(1)