Skip to content
The Chat Archive
gemini-2.5-flash-preview-04-17· Google LMArena Human Preference 140K

Добавь tqdm: import requests, hashlib, os API =…

  1. User

    Добавь tqdm: import requests, hashlib, os

    API = "https://commons.wikimedia.org/w/api.php" params = { 'action': 'query', 'list': 'categorymembers', 'cmtitle': 'Category:Audio_files', 'cmtype': 'file', 'cmlimit': 'max', 'format': 'json' } res = requests.get(API, params=params).json() for item in res['query']['categorymembers']: title = item['title'] # например "File:Example.ogg" # Получаем информацию о файле, включая URL оригинала res2 = requests.get(API, params={ 'action': 'query', 'titles': title, 'prop': 'imageinfo', 'iiprop': 'url', 'format': 'json' }).json() pages = res2['query']['pages'] for page in pages.values(): if 'imageinfo' not in page: continue file_url = page['imageinfo'][0]['url'] content = requests.get(file_url).content h = hashlib.md5(content).hexdigest() if h in hashes: continue hashes.add(h) filename = os.path.basename(file_url) os.makedirs('downloads/commons', exist_ok=True) with open(f"downloads/commons/{filename}", 'wb') as f: f.write(content) metadata.append({'source_url': file_url, 'filename': filename})

  2. Assistant

    Конечно, давайте добавим tqdm для отображения прогресса.

    1. Установите tqdm, если еще не установили:

      pip install tqdm
      
    2. Импортируйте tqdm и оберните цикл обработки элементов категории.

    Вот модифицированный код:

    import requests
    import hashlib
    import os
    from tqdm import tqdm  # Импортируем tqdm
    
    API = "https://commons.wikimedia.org/w/api.php"
    
    # Инициализируем set для хешей и list для метаданных,
    # так как они используются, но не были инициализированы в вашем фрагменте.
    hashes = set()
    metadata = []
    
    # --- Шаг 1: Получение списка файлов в категории ---
    # Обратите внимание: cmlimit='max' пытается получить максимум за один запрос,
    # но для очень больших категорий может потребоваться обработка продолжения (cmcontinue).
    # Этот код обрабатывает только первую страницу результатов.
    params_list = {
        'action': 'query',
        'list': 'categorymembers',
        'cmtitle': 'Category:Audio_files',
        'cmtype': 'file',
        'cmlimit': 'max',
        'format': 'json'
    }
    
    print("Получение списка файлов из категории...")
    res_list = requests.get(API, params=params_list).json()
    
    # Проверяем, получены ли элементы
    if 'query' not in res_list or 'categorymembers' not in res_list['query']:
        print("Не удалось получить список файлов или категория пуста.")
        exit()
    
    category_members = res_list['query']['categorymembers']
    print(f"Найдено {len(category_members)} файлов в первой странице результатов.")
    
    # --- Шаг 2: Обработка каждого файла с прогресс-баром ---
    os.makedirs('downloads/commons', exist_ok=True) # Создаем директорию заранее
    
    # Оборачиваем итератор category_members с помощью tqdm
    for item in tqdm(category_members, desc="Скачивание и обработка файлов"):
        title = item['title']  # например "File:Example.ogg"
    
        # Получаем информацию о файле, включая URL оригинала
        params_info = {
            'action': 'query',
            'titles': title,
            'prop': 'imageinfo',
            'iiprop': 'url',
            'format': 'json'
        }
        res_info = requests.get(API, params=params_info).json()
    
        # Находим информацию о странице и файле
        pages = res_info['query']['pages']
        for page in pages.values(): # Обычно здесь только одна страница, т.к. мы запросили один title
            if 'imageinfo' not in page:
                tqdm.write(f"Пропущено {title}: нет imageinfo") # Используем tqdm.write для вывода без нарушения бара
                continue
    
            file_url = page['imageinfo'][0]['url']
    
            try:
                # Скачиваем контент файла
                content = requests.get(file_url).content
    
                # Вычисляем хеш
                h = hashlib.md5(content).hexdigest()
    
                # Проверяем на дубликаты по хешу
                if h in hashes:
                    # tqdm.write(f"Пропущено {title}: дубликат по хешу") # Можно раскомментировать для отладки дубликатов
                    continue
                hashes.add(h)
    
                # Определяем имя файла из URL и сохраняем
                filename = os.path.basename(file_url)
    
                filepath = f"downloads/commons/{filename}"
                with open(filepath, 'wb') as f:
                    f.write(content)
    
                # Добавляем метаданные
                metadata.append({'source_url': file_url, 'filename': filename})
                # tqdm.write(f"Сохранено {filename}") # Можно раскомментировать для отладки сохранения
            except requests.exceptions.RequestException as e:
                 tqdm.write(f"Ошибка при скачивании {file_url}: {e}")
            except Exception as e:
                 tqdm.write(f"Произошла ошибка при обработке {title}: {e}")
    
    
    print("\nОбработка завершена.")
    print(f"Скачано и сохранено {len(metadata)} уникальных файлов.")
    # Теперь у вас есть список metadata и set hashes после цикла
    # print("Метаданные:", metadata) # Можно раскомментировать для просмотра результатов
    

    Изменения:

    1. from tqdm import tqdm: Импортирует класс tqdm.
    2. for item in tqdm(category_members, desc="Скачивание и обработка файлов"):: Оборачивает цикл for вокруг tqdm.
      • Первым аргументом передается итерируемый объект (category_members).
      • desc добавляет описание к прогресс-бару, что делает его более понятным.
    3. tqdm.write(...): Заменил стандартный print на tqdm.write внутри цикла. Это гарантирует, что вывод не нарушит отображение прогресс-бара.
    4. Добавлены инициализации hashes = set() и metadata = [], чтобы код был более полным и исполняемым.
    5. Добавлена простая обработка ошибок при запросах.
    6. Переименованы переменные res и res2 на более описательные res_list и res_info.
    7. Создание директории перенесено до цикла.

    Теперь при запуске скрипта вы увидите динамический прогресс-бар, показывающий, сколько файлов из первой страницы результатов категории уже обработано.

  3. User

    Исправь сохранения звуков, чтобы они сохранялись корректно. Так же исправь названия

  4. Assistant

    Конечно, давайте улучшим сохранение звуков и их названия.

    Основные улучшения:

    1. Санитизация названий файлов: Использование os.path.basename(file_url) может привести к проблемам с символами, недопустимыми в именах файлов в различных операционных системах, или к длинным/непонятным именам. Лучше взять название из item['title'] (например, "File:Example.ogg") и очистить его от префикса "File:" и некорректных символов.
    2. Потоковое скачивание: Скачивание всего контента файла в память (requests.get(...).content) может быть неэффективным и вызвать проблемы с памятью для очень больших файлов. Лучше использовать потоковое скачивание и запись данных по частям прямо в файл.
    3. Использование SHA1 из API для дубликатов: Wikimedia Commons API часто предоставляет SHA1 хеш файла. Использовать этот хеш для проверки дубликатов до скачивания файла гораздо эффективнее, чем скачивать файл и потом считать MD5.

    Вот обновленный код с этими улучшениями:

    import requests
    import hashlib
    import os
    from tqdm import tqdm
    import re # Импортируем модуль для регулярных выражений для санитизации
    
    API = "https://commons.wikimedia.org/w/api.php"
    
    # Инициализируем set для хешей (будем использовать SHA1) и list для метаданных
    hashes = set()
    metadata = []
    
    # Функция для очистки названия файла
    def sanitize_filename(title):
        """Удаляет префикс 'File:' и некорректные символы из названия файла."""
        # Удаляем префикс 'File:'
        name = title.replace('File:', '', 1) # Используем count=1 на случай, если 'File:' есть внутри названия
    
        # Определяем недопустимые символы (общие для Windows, macOS, Linux)
        # Также добавляем управляющие символы (\x00-\x1f)
        # Заменяем их на подчеркивание
        invalid_chars_pattern = r'[<>:"/\\|?*\x00-\x1f]'
        cleaned_name = re.sub(invalid_chars_pattern, '_', name)
    
        # Опционально: удалить ведущие/замыкающие пробелы или точки (особенность Windows)
        cleaned_name = cleaned_name.strip()
        if cleaned_name.endswith('.'):
             cleaned_name = cleaned_name[:-1]
    
        # Если после очистки имя стало пустым (крайне маловероятно для Commons),
        # используем хеш как запасной вариант.
        if not cleaned_name:
            cleaned_name = hashlib.md5(title.encode('utf-8')).hexdigest() + ".dat" # Добавляем расширение, чтобы файл не был без расширения
    
        return cleaned_name
    
    # --- Шаг 1: Получение списка файлов в категории ---
    # Обратите внимание: cmlimit='max' пытается получить максимум за один запрос,
    # но для очень больших категорий может потребоваться обработка продолжения (cmcontinue).
    # Этот код обрабатывает только первую страницу результатов.
    params_list = {
        'action': 'query',
        'list': 'categorymembers',
        'cmtitle': 'Category:Audio_files',
        'cmtype': 'file',
        'cmlimit': 'max', # Wikimedia может вернуть меньше, чем max, и указать 'continue'
        'format': 'json'
    }
    
    print("Получение списка файлов из категории...")
    all_category_members = []
    continue_param = None
    
    # Обработка пагинации (если категория очень большая)
    while True:
        current_params = params_list.copy()
        if continue_param:
            current_params['cmcontinue'] = continue_param
    
        try:
            res_list = requests.get(API, params=current_params).json()
        except requests.exceptions.RequestException as e:
            print(f"Ошибка при получении списка файлов: {e}")
            break
    
        if 'error' in res_list:
            print(f"Ошибка API: {res_list['error']['info']}")
            break
    
        if 'query' not in res_list or 'categorymembers' not in res_list['query']:
            print("Не удалось получить список файлов или категория пуста.")
            break # Или continue, если ожидаем больше страниц
    
        all_category_members.extend(res_list['query']['categorymembers'])
        print(f"Получено {len(res_list['query']['categorymembers'])} записей на текущей странице. Всего: {len(all_category_members)}")
    
        if 'continue' in res_list and 'cmcontinue' in res_list['continue']:
            continue_param = res_list['continue']['cmcontinue']
        else:
            break # Больше страниц нет
    
    print(f"Всего найдено {len(all_category_members)} файлов в категории.")
    
    if not all_category_members:
        print("Список файлов пуст. Завершение.")
        exit()
    
    
    # --- Шаг 2: Обработка каждого файла с прогресс-баром ---
    download_dir = 'downloads/commons'
    os.makedirs(download_dir, exist_ok=True) # Создаем директорию заранее
    
    # Оборачиваем итератор all_category_members с помощью tqdm
    for item in tqdm(all_category_members, desc="Скачивание и обработка файлов"):
        title = item['title']  # например "File:Example.ogg"
        filename = sanitize_filename(title) # Очищенное название файла
        filepath = os.path.join(download_dir, filename) # Полный путь к файлу
    
        # Получаем информацию о файле, включая URL оригинала, SHA1 и размер
        params_info = {
            'action': 'query',
            'titles': title,
            'prop': 'imageinfo',
            'iiprop': 'url|sha1|size', # Добавили sha1 и size для проверки дубликатов и информации
            'format': 'json'
        }
        try:
            res_info = requests.get(API, params=params_info).json()
        except requests.exceptions.RequestException as e:
            tqdm.write(f"Ошибка API при получении info для {title}: {e}")
            continue # Переходим к следующему файлу
    
        if 'error' in res_info:
            tqdm.write(f"Ошибка API info для {title}: {res_info['error']['info']}")
            continue
    
        # Находим информацию о странице и файле
        pages = res_info['query']['pages']
        page_info_data = None
        for page_id, page_data in pages.items():
             if 'imageinfo' in page_data:
                 page_info_data = page_data['imageinfo'][0]
                 break # Обычно здесь только одна страница, т.к. мы запросили один title
    
        if not page_info_data:
             tqdm.write(f"Пропущено {title}: нет полной imageinfo")
             continue
    
        file_url = page_info_data.get('url')
        sha1_hash = page_info_data.get('sha1')
        file_size = page_info_data.get('size', 0) # Размер файла в байтах
    
        if not file_url:
             tqdm.write(f"Пропущено {title}: нет URL файла")
             continue
    
        # --- Проверка на дубликаты по SHA1 (если доступен) ---
        # Если SHA1 доступен и мы его уже видели, пропускаем скачивание
        if sha1_hash and sha1_hash in hashes:
            # tqdm.write(f"Пропущено {title}: дубликат по SHA1 ({sha1_hash})") # Опциональный вывод
            # Добавляем запись в метаданные, отмечая как пропущенный дубликат
            metadata.append({'source_url': file_url, 'filename': filename, 'sha1': sha1_hash, 'status': 'skipped_duplicate'})
            continue
    
        # --- Скачиваем файл с использованием потока ---
        try:
            # Используем stream=True для потокового скачивания
            response = requests.get(file_url, stream=True)
            response.raise_for_status() # Проверяем на ошибки HTTP (4xx, 5xx)
    
            # Получаем размер файла из заголовков, если доступно (для более точного внутреннего прогресса)
            # total_size = int(response.headers.get('content-length', 0)) # Можно использовать для внутреннего tqdm
    
            # Если файл успешно скачался, добавляем его SHA1 (или другой хеш) в set
            # ЭТО ВАЖНО: добавляем хеш только ПОСЛЕ успешного скачивания и проверки
            # (или после проверки SHA1, если он есть).
    
            # Открываем файл для записи в бинарном режиме
            with open(filepath, 'wb') as f:
                # Записываем файл по частям
                # Можно добавить внутренний tqdm здесь, если нужен прогресс по каждому файлу
                # with tqdm(total=total_size, unit='iB', unit_scale=True, desc=filename, leave=False) as inner_tqdm:
                for chunk in response.iter_content(chunk_size=8192): # Размер чанка, например 8KB
                    if chunk: # filter out keep-alive new chunks
                        f.write(chunk)
                        # inner_tqdm.update(len(chunk))
    
            # --- Проверка хеша после скачивания (опционально, но рекомендуется) ---
            # Если SHA1 был получен из API, пересчитываем его для скачанного файла
            # и сравниваем.
            calculated_hash = None
            if sha1_hash:
                 hasher = hashlib.sha1()
                 try:
                     with open(filepath, 'rb') as f:
                         while chunk := f.read(8192):
                             hasher.update(chunk)
                     calculated_hash = hasher.hexdigest()
    
                     if calculated_hash != sha1_hash:
                         tqdm.write(f"ВНИМАНИЕ: Несоответствие SHA1 для скачанного {filename}! API: {sha1_hash}, Скачано: {calculated_hash}. Файл сохранен, но возможна проблема.")
                         # Решите, что делать дальше: удалить файл, пометить ошибку и т.д.
                         # В этом примере просто выводим предупреждение.
    
                 except IOError as e:
                      tqdm.write(f"Ошибка при чтении скачанного файла {filename} для проверки хеша: {e}")
                      calculated_hash = "error_calculating_hash"
    
    
            # Используем SHA1 из API как основной идентификатор. Если его не было,
            # можно рассчитать MD5 для надежности, хотя проверка по SHA1 до скачивания лучше.
            # Добавляем хеш, который будем использовать для отслеживания дубликатов
            final_hash_for_set = sha1_hash or calculated_hash # Предпочитаем SHA1 из API
    
            # Проверяем еще раз на дубликаты, если вдруг SHA1 не был доступен изначально
            # и мы только что рассчитали хеш.
            if final_hash_for_set and final_hash_for_set in hashes:
                 tqdm.write(f"Обнаружен дубликат по хешу {final_hash_for_set} после скачивания для {filename}. Удаление файла.")
                 try:
                     os.remove(filepath)
                 except OSError as e:
                     tqdm.write(f"Ошибка при удалении дубликата {filepath}: {e}")
                 # Добавляем запись в метаданные, отмечая как удаленный дубликат
                 metadata.append({'source_url': file_url, 'filename': filename, 'sha1': final_hash_for_set, 'status': 'deleted_duplicate_post_download'})
                 continue # Пропускаем добавление в метаданные как успешно сохраненного
    
    
            # Добавляем хеш в set только после успешного сохранения файла
            if final_hash_for_set: # Убедимся, что хеш не None
                 hashes.add(final_hash_for_set)
            else:
                 # Если SHA1 не был доступен и не удалось рассчитать хеш,
                 # принимаем риск потенциального дубликата или помечаем как ошибку.
                 tqdm.write(f"ВНИМАНИЕ: Не удалось получить или рассчитать хеш для {filename}. Дубликаты могут быть не обнаружены.")
                 # Можно использовать filename+size как менее надежный идентификатор, но это ненадежно.
                 # hashes.add(f"{filename}_{file_size}") # Пример ненадежного идентификатора
    
            # Добавляем метаданные для успешно сохраненного уникального файла
            metadata_entry = {
                'source_url': file_url,
                'filename': filename,
                'sha1': sha1_hash, # Сохраняем SHA1 из API, даже если не смогли его перепроверить или его не было
                'calculated_hash': calculated_hash if not sha1_hash else None, # Сохраняем рассчитанный хеш, если не было SHA1 из API
                'size_bytes': file_size,
                'status': 'saved_successfully'
                }
            metadata.append(metadata_entry)
            # tqdm.write(f"Сохранено: {filename}") # Опциональное логирование успешного сохранения
    
        except requests.exceptions.RequestException as e:
             tqdm.write(f"Ошибка при скачивании {file_url} ({filename}): {e}")
             # Добавляем запись в метаданные с ошибкой скачивания
             metadata.append({'source_url': file_url, 'filename': filename, 'status': f'download_error: {e}'})
    
        except Exception as e:
             tqdm.write(f"Произошла непредвиденная ошибка при обработке {title} ({filename}): {e}")
             # Добавляем запись в метаданные с общей ошибкой
             metadata.append({'source_url': file_url, 'filename': filename, 'status': f'processing_error: {e}'})
    
    
    print("\nОбработка завершена.")
    print(f"Всего найдено файлов в категории (на первой странице): {len(all_category_members)}")
    
    # Подсчитываем количество сохраненных уникальных файлов по статусу в метаданных
    saved_count = sum(1 for item in metadata if item.get('status') == 'saved_successfully')
    skipped_duplicate_count = sum(1 for item in metadata if item.get('status') == 'skipped_duplicate')
    deleted_duplicate_count = sum(1 for item in metadata if item.get('status') == 'deleted_duplicate_post_download')
    download_error_count = sum(1 for item in metadata if item.get('status') and 'download_error' in item.get('status'))
    processing_error_count = sum(1 for item in metadata if item.get('status') and 'processing_error' in item.get('status'))
    
    
    print(f"Результаты:")
    print(f"  Успешно сохранено: {saved_count}")
    print(f"  Пропущено (дубликат до скачивания): {skipped_duplicate_count}")
    print(f"  Удалено (дубликат после скачивания): {deleted_duplicate_count}")
    print(f"  Ошибки скачивания: {download_error_count}")
    print(f"  Ошибки обработки: {processing_error_count}")
    print(f"  Всего записей в метаданных: {len(metadata)}") # Должно примерно совпадать с количеством processed_items
    
    
    # Теперь у вас есть список metadata и set hashes после цикла
    # print("Метаданные:", metadata) # Можно раскомментировать для просмотра всех результатов
    

    Основные изменения:

    1. Функция sanitize_filename(title): Извлекает часть после "File:", удаляет недопустимые символы и возвращает чистое имя файла.
    2. Использование очищенного названия: Переменная filename теперь создается с помощью sanitize_filename(title), и этот filename используется для сохранения файла.
    3. Пагинация: Добавлен простой цикл while True для обработки параметра cmcontinue и получения всех (или хотя бы большего количества) элементов категории, если их больше, чем вмещается на одной странице запроса (cmlimit=max).
    4. Параметры API для imageinfo: В запрос params_info добавлены sha1 и size в iiprop.
    5. Проверка дубликатов по SHA1 до скачивания: Полученный из API sha1_hash используется для проверки if sha1_hash in hashes: перед началом скачивания. Если хеш уже есть, файл считается дубликатом и пропускается.
    6. Потоковое скачивание: Используется requests.get(..., stream=True) и цикл for chunk in response.iter_content(...) для скачивания и записи файла по частям, что более эффективно для больших файлов.
    7. Проверка хеша после скачивания: Если SHA1 был доступен из API, код теперь пересчитывает SHA1 скачанного файла и сравнивает его с API хешем для дополнительной проверки целостности.
    8. Обновление hashes и metadata: Хеш добавляется в hashes только после успешного сохранения файла и, опционально, проверки хеша. Метаданные теперь включают SHA1 (если доступен) и статус операции ('saved_successfully', 'skipped_duplicate', 'download_error', и т.д.).
    9. Расширенная обработка ошибок: Добавлены блоки try...except для запросов и процесса скачивания/сохранения, выводящие сообщения об ошибках без прерывания всего скрипта.
    10. Статистика: В конце выводится сводная статистика по количеству успешно сохраненных, пропущенных и ошибочных файлов на основе данных в metadata.

    Теперь скрипт должен скачивать звуки более надежно, давать им более корректные названия и эффективно обрабатывать дубликаты, особенно если SHA1 доступен через API.

Responses were produced in different, uncontrolled contexts (system prompts, settings, prior turns). This is not a benchmark.