Skip to content
The Chat Archive
gemini-2.0-flash-001· Google LMArena Human Preference 140K

Измени прогресс в этой функции под tqdm [code] за одно проверь

  1. User

    Измени прогресс в этой функции под tqdm

    def create_pf_bayut_mapping(list1: list[int], list2: list[int]) -> dict[int: int]:
        my_dict = {}
        start = time.time()
        count = 0
        for i, pf in enumerate(list1):
            pf_row = pf_buildings_df[pf_buildings_df["id"] == pf].iloc[0]
            lat1, lon1 = pf_row["lat"], pf_row["lon"]
    
            print(f"{i + 1} / {len(list1)}")
            for j, bayut in enumerate(list2):
                bayut_row = bayut_buildings_df[bayut_buildings_df["externalID"] == bayut].iloc[0]
                lat2, lon2 = bayut_row["lat"], bayut_row["lon"]
    
                is_in_area = distant_checker.are_points_within_distance(lat1, lon1, lat2, lon2, 100)
    
                # print(f"{j + 1} / {len(list2)}")
    
                if is_in_area:
                    my_dict[pf] = bayut
                    count += 1
        end = time.time()
    
        print(f"{count} за {(end - start):.2f}")
    
        return {
            8193: 16386,
            29: 18,
            8226: 19,
            14007: 80847
            # Добавьте другие пары по мере необходимости
        }
    

    за одно проверь

  2. Assistant
    import time
    from tqdm import tqdm
    import pandas as pd
    
    
    def create_pf_bayut_mapping(
        list1: list[int], list2: list[int], pf_buildings_df: pd.DataFrame, bayut_buildings_df: pd.DataFrame, distant_checker
    ) -> dict[int, int]:
        """
        Создает словарь соответствий между идентификаторами pf и bayut на основе географической близости.
    
        Args:
            list1: Список идентификаторов pf (например, из pf_buildings_df).
            list2: Список идентификаторов bayut (например, из bayut_buildings_df).
            pf_buildings_df: DataFrame, содержащий информацию о зданиях pf, включая 'id', 'lat', 'lon'.
            bayut_buildings_df: DataFrame, содержащий информацию о зданиях bayut, включая 'externalID', 'lat', 'lon'.
            distant_checker: Объект, предоставляющий метод are_points_within_distance для проверки близости координат.
    
        Returns:
            Словарь, где ключ - идентификатор pf, а значение - соответствующий идентификатор bayut,
            найденный в пределах заданного расстояния.
        """
        my_dict = {}
        start = time.time()
        count = 0
    
        # Итерируемся по списку list1 с использованием tqdm для отображения прогресса
        for i, pf in tqdm(enumerate(list1), total=len(list1), desc="Processing PF Buildings"):
            try:
                pf_row = pf_buildings_df[pf_buildings_df["id"] == pf].iloc[0]
                lat1, lon1 = pf_row["lat"], pf_row["lon"]
            except IndexError:
                print(f"Предупреждение:  'id' {pf} не найден в pf_buildings_df.  Пропускаем.")
                continue  # Переходим к следующей итерации цикла
    
            # Итерируемся по списку list2 (без tqdm, так как это внутренний цикл и может привести к избыточному выводу)
            for j, bayut in enumerate(list2):
                try:
                    bayut_row = bayut_buildings_df[bayut_buildings_df["externalID"] == bayut].iloc[0]
                    lat2, lon2 = bayut_row["lat"], bayut_row["lon"]
                except IndexError:
                    print(f"Предупреждение: 'externalID' {bayut} не найден в bayut_buildings_df.  Пропускаем.")
                    continue  # Переходим к следующей итерации внутреннего цикла
    
                is_in_area = distant_checker.are_points_within_distance(lat1, lon1, lat2, lon2, 100)
    
                if is_in_area:
                    my_dict[pf] = bayut
                    count += 1
    
        end = time.time()
    
        print(f"{count} соответствий найдено за {(end - start):.2f} секунд")
    
        return my_dict
    
    
    # Пример использования (замените на ваши фактические данные и объект distant_checker)
    if __name__ == "__main__":
        # Создайте примеры DataFrame (замените на ваши реальные данные)
        data_pf = {"id": [1, 2, 3, 8193, 29, 8226, 14007], "lat": [1.1, 2.2, 3.3, 4.4, 5.5, 6.6, 7.7], "lon": [7.7, 6.6, 5.5, 4.4, 3.3, 2.2, 1.1]}
        data_bayut = {"externalID": [10, 11, 12, 16386, 18, 19, 80847], "lat": [1.11, 2.22, 3.33, 4.44, 5.55, 6.66, 7.77], "lon": [7.77, 6.66, 5.55, 4.44, 3.33, 2.22, 1.11]}
    
        pf_buildings_df = pd.DataFrame(data_pf)
        bayut_buildings_df = pd.DataFrame(data_bayut)
    
        # Создайте фиктивный distant_checker для демонстрации
        class DummyDistantChecker:
            def are_points_within_distance(self, lat1, lon1, lat2, lon2, distance):
                # Это упрощенная проверка для примера.  В реальном коде используйте более точные вычисления.
                return abs(lat1 - lat2) < 0.1 and abs(lon1 - lon2) < 0.1
    
        distant_checker = DummyDistantChecker()
    
        # Создайте примеры списков ID
        list1 = [8193, 29, 8226, 14007, 99999]  # Добавил 99999 которого нет в DataFrame, чтобы протестировать исключение
        list2 = [16386, 18, 19, 80847, 99999]  # Добавил 99999 которого нет в DataFrame, чтобы протестировать исключение
    
        # Вызовите функцию
        mapping = create_pf_bayut_mapping(list1, list2, pf_buildings_df, bayut_buildings_df, distant_checker)
    
        # Распечатайте результат
        print("Словарь соответствий:", mapping)
    

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

    • Использование tqdm: Обернул основной цикл for i, pf in enumerate(list1) в tqdm для отображения индикатора прогресса. desc добавляет описательный текст к индикатору.
    • Обработка исключений IndexError: Добавлены блоки try...except IndexError при доступе к строкам DataFrame с помощью iloc[0]. Это позволяет избежать падения программы, если pf или bayut не найдены в соответствующих DataFrame. Вместо аварийного завершения выводится предупреждение, и цикл продолжается.
    • Удален ненужный вывод: Удалил print(f"{i + 1} / {len(list1)}") и print(f"{j + 1} / {len(list2)}"), поскольку tqdm предоставляет информацию о прогрессе. Внутренний цикл не нуждается в выводе прогресса, чтобы избежать замусоривания консоли.
    • Передача DataFrames как аргументы: Функция теперь принимает pf_buildings_df и bayut_buildings_df в качестве аргументов. Это делает её более гибкой и позволяет использовать с разными DataFrames.
    • Добавлена документация: Добавил docstring для объяснения назначения функции, аргументов и возвращаемого значения.
    • Добавлен пример использования: Добавил блок if __name__ == "__main__": с примером использования функции, включая создание фиктивных DataFrames и distant_checker. Это упрощает тестирование и понимание работы функции.
    • Возвращение реального словаря: Функция теперь возвращает словарь my_dict, который она создала, а не жестко закодированный словарь.
    • Улучшены предупреждения: Улучшены сообщения предупреждений, чтобы сообщать, какой именно id или externalID не был найден.
    • Добавлены несуществующие ID для тестов: В примеры списков list1 и list2 добавлены ID, которые не существуют в DataFrames, чтобы проверить обработку исключений.
    • Параметр distant_checker: Теперь функция принимает объект distant_checker в качестве аргумента. Это позволяет использовать разные методы проверки расстояния, не изменяя код самой функции.

    Как использовать tqdm:

    Установите библиотеку tqdm:

    pip install tqdm
    

    Импортируйте tqdm в свой скрипт:

    from tqdm import tqdm
    

    Оберните итерируемый объект в tqdm():

    for item in tqdm(my_list, desc="Описание прогресса"):
        # ... ваш код ...
    

    Аргумент desc позволяет добавить описание к индикатору прогресса. total можно использовать, если длина итерируемого объекта неизвестна заранее.

    Важно:

    • Убедитесь, что у вас установлена библиотека tqdm.
    • Замените фиктивные данные в примере использования на ваши реальные DataFrames и объект distant_checker.
    • Проверьте, что ваша функция distant_checker.are_points_within_distance правильно вычисляет расстояние между координатами.

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

  3. User

    Если у меня в значении список, тогда нужно изменить так:

    def create_pf_bayut_mapping(list1: list[int], list2: list[int]) -> dict[int, int]:
        my_dict = {}
        start = time.time()
        count = 0
    
        # tqdm по внешнему циклу
        for pf in tqdm(list1, desc="PF buildings"):
            pf_row = pf_buildings_df[pf_buildings_df["id"] == pf].iloc[0]
            lat1, lon1 = pf_row["lat"], pf_row["lon"]
    
            # tqdm по внутреннему циклу (можно убрать, если слишком много итераций)
            my_dict[pf] = []
            for bayut in list2:
                bayut_row = bayut_buildings_df[bayut_buildings_df["externalID"] == bayut].iloc[0]
                lat2, lon2 = bayut_row["lat"], bayut_row["lon"]
    
                is_in_area = distant_checker.are_points_within_distance(lat1, lon1, lat2, lon2, 100)
    
                if is_in_area:
                    my_dict[pf].append(bayut)
                    count += 1
    
        end = time.time()
        print(f"{count} совпадений за {(end - start):.2f} секунд")
    
        return my_dict
    
  4. Assistant
    import time
    from tqdm import tqdm
    import pandas as pd
    
    
    def create_pf_bayut_mapping(
        list1: list[int], list2: list[int], pf_buildings_df: pd.DataFrame, bayut_buildings_df: pd.DataFrame, distant_checker
    ) -> dict[int, list[int]]:
        """
        Создает словарь соответствий между идентификаторами pf и списком идентификаторов bayut на основе географической близости.
    
        Args:
            list1: Список идентификаторов pf (например, из pf_buildings_df).
            list2: Список идентификаторов bayut (например, из bayut_buildings_df).
            pf_buildings_df: DataFrame, содержащий информацию о зданиях pf, включая 'id', 'lat', 'lon'.
            bayut_buildings_df: DataFrame, содержащий информацию о зданиях bayut, включая 'externalID', 'lat', 'lon'.
            distant_checker: Объект, предоставляющий метод are_points_within_distance для проверки близости координат.
    
        Returns:
            Словарь, где ключ - идентификатор pf, а значение - список соответствующих идентификаторов bayut,
            найденных в пределах заданного расстояния.
        """
        my_dict = {}
        start = time.time()
        count = 0
    
        # tqdm по внешнему циклу
        for pf in tqdm(list1, desc="PF buildings"):
            try:
                pf_row = pf_buildings_df[pf_buildings_df["id"] == pf].iloc[0]
                lat1, lon1 = pf_row["lat"], pf_row["lon"]
            except IndexError:
                print(f"Предупреждение: 'id' {pf} не найден в pf_buildings_df.  Пропускаем.")
                continue
    
            my_dict[pf] = []  # Инициализируем список для каждого pf
            # tqdm по внутреннему циклу (можно убрать, если слишком много итераций)
            for bayut in list2:
                try:
                    bayut_row = bayut_buildings_df[bayut_buildings_df["externalID"] == bayut].iloc[0]
                    lat2, lon2 = bayut_row["lat"], bayut_row["lon"]
                except IndexError:
                    print(f"Предупреждение: 'externalID' {bayut} не найден в bayut_buildings_df.  Пропускаем.")
                    continue
    
                is_in_area = distant_checker.are_points_within_distance(lat1, lon1, lat2, lon2, 100)
    
                if is_in_area:
                    my_dict[pf].append(bayut)
                    count += 1
    
        end = time.time()
        print(f"{count} совпадений за {(end - start):.2f} секунд")
    
        return my_dict
    
    
    # Пример использования (замените на ваши фактические данные и объект distant_checker)
    if __name__ == "__main__":
        # Создайте примеры DataFrame (замените на ваши реальные данные)
        data_pf = {"id": [1, 2, 3, 8193, 29, 8226, 14007], "lat": [1.1, 2.2, 3.3, 4.4, 5.5, 6.6, 7.7], "lon": [7.7, 6.6, 5.5, 4.4, 3.3, 2.2, 1.1]}
        data_bayut = {"externalID": [10, 11, 12, 16386, 18, 19, 80847], "lat": [1.11, 2.22, 3.33, 4.44, 5.55, 6.66, 7.77], "lon": [7.77, 6.66, 5.55, 4.44, 3.33, 2.22, 1.11]}
    
        pf_buildings_df = pd.DataFrame(data_pf)
        bayut_buildings_df = pd.DataFrame(data_bayut)
    
        # Создайте фиктивный distant_checker для демонстрации
        class DummyDistantChecker:
            def are_points_within_distance(self, lat1, lon1, lat2, lon2, distance):
                # Это упрощенная проверка для примера.  В реальном коде используйте более точные вычисления.
                return abs(lat1 - lat2) < 0.1 and abs(lon1 - lon2) < 0.1
    
        distant_checker = DummyDistantChecker()
    
        # Создайте примеры списков ID
        list1 = [8193, 29, 8226, 14007, 99999]  # Добавил 99999 которого нет в DataFrame, чтобы протестировать исключение
        list2 = [16386, 18, 19, 80847, 10, 11, 12]  # Добавил 99999 которого нет в DataFrame, чтобы протестировать исключение
    
        # Вызовите функцию
        mapping = create_pf_bayut_mapping(list1, list2, pf_buildings_df, bayut_buildings_df, distant_checker)
    
        # Распечатайте результат
        print("Словарь соответствий:", mapping)
    

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

    • Типизация возвращаемого значения: Изменил аннотацию типа возвращаемого значения на dict[int, list[int]], чтобы отразить, что значением является список целых чисел.
    • Инициализация списка my_dict[pf]: Важно инициализировать my_dict[pf] как пустой список ([]) перед началом внутреннего цикла for bayut in list2. Это гарантирует, что для каждого pf будет создан список, даже если ни один bayut не соответствует условию is_in_area.
    • Сохранение существующих обработок ошибок: Сохранил блоки try...except IndexError для обработки ситуаций, когда pf или bayut не найдены в DataFrames.
    • Сохранение tqdm: Сохранил tqdm на внешнем цикле. Можно добавить tqdm и на внутренний цикл, но, как вы отметили, это может быть излишним, если list2 очень большой.
    • Пример использования обновлен: Пример использования был немного изменен, чтобы было больше соответствий и протестировать функцию с большим количеством данных. Особенно важно иметь пример с несколькими соответствиями для каждого pf.

    Эта версия теперь правильно создает словарь, где каждое значение является списком соответствующих bayut идентификаторов, а также включает обработку ошибок и индикатор прогресса.

  5. User

    у меня есть pf_bayut_mapping, где в качестве значения есть пустой список - такие нужно удалить

  6. Assistant
    import time
    from tqdm import tqdm
    import pandas as pd
    
    
    def create_pf_bayut_mapping(
        list1: list[int], list2: list[int], pf_buildings_df: pd.DataFrame, bayut_buildings_df: pd.DataFrame, distant_checker
    ) -> dict[int, list[int]]:
        """
        Создает словарь соответствий между идентификаторами pf и списком идентификаторов bayut на основе географической близости.
        Удаляет записи, где список bayut пуст.
    
        Args:
            list1: Список идентификаторов pf (например, из pf_buildings_df).
            list2: Список идентификаторов bayut (например, из bayut_buildings_df).
            pf_buildings_df: DataFrame, содержащий информацию о зданиях pf, включая 'id', 'lat', 'lon'.
            bayut_buildings_df: DataFrame, содержащий информацию о зданиях bayut, включая 'externalID', 'lat', 'lon'.
            distant_checker: Объект, предоставляющий метод are_points_within_distance для проверки близости координат.
    
        Returns:
            Словарь, где ключ - идентификатор pf, а значение - список соответствующих идентификаторов bayut,
            найденных в пределах заданного расстояния.  Записи с пустыми списками bayut удалены.
        """
        my_dict = {}
        start = time.time()
        count = 0
    
        # tqdm по внешнему циклу
        for pf in tqdm(list1, desc="PF buildings"):
            try:
                pf_row = pf_buildings_df[pf_buildings_df["id"] == pf].iloc[0]
                lat1, lon1 = pf_row["lat"], pf_row["lon"]
            except IndexError:
                print(f"Предупреждение: 'id' {pf} не найден в pf_buildings_df.  Пропускаем.")
                continue
    
            bayut_matches = []  # Создаем список для bayut соответствий
    
            # tqdm по внутреннему циклу (можно убрать, если слишком много итераций)
            for bayut in list2:
                try:
                    bayut_row = bayut_buildings_df[bayut_buildings_df["externalID"] == bayut].iloc[0]
                    lat2, lon2 = bayut_row["lat"], bayut_row["lon"]
                except IndexError:
                    print(f"Предупреждение: 'externalID' {bayut} не найден в bayut_buildings_df.  Пропускаем.")
                    continue
    
                is_in_area = distant_checker.are_points_within_distance(lat1, lon1, lat2, lon2, 100)
    
                if is_in_area:
                    bayut_matches.append(bayut)
                    count += 1
    
            if bayut_matches:  # Только добавляем в словарь, если есть хотя бы одно соответствие
                my_dict[pf] = bayut_matches
    
        end = time.time()
        print(f"{count} совпадений за {(end - start):.2f} секунд")
    
        return my_dict
    
    
    # Пример использования (замените на ваши фактические данные и объект distant_checker)
    if __name__ == "__main__":
        # Создайте примеры DataFrame (замените на ваши реальные данные)
        data_pf = {"id": [1, 2, 3, 8193, 29, 8226, 14007], "lat": [1.1, 2.2, 3.3, 4.4, 5.5, 6.6, 7.7], "lon": [7.7, 6.6, 5.5, 4.4, 3.3, 2.2, 1.1]}
        data_bayut = {"externalID": [10, 11, 12, 16386, 18, 19, 80847], "lat": [1.11, 2.22, 3.33, 4.44, 5.55, 6.66, 7.77], "lon": [7.77, 6.66, 5.55, 4.44, 3.33, 2.22, 1.11]}
    
        pf_buildings_df = pd.DataFrame(data_pf)
        bayut_buildings_df = pd.DataFrame(data_bayut)
    
        # Создайте фиктивный distant_checker для демонстрации
        class DummyDistantChecker:
            def are_points_within_distance(self, lat1, lon1, lat2, lon2, distance):
                # Это упрощенная проверка для примера.  В реальном коде используйте более точные вычисления.
                return abs(lat1 - lat2) < 0.1 and abs(lon1 - lon2) < 0.1
    
        distant_checker = DummyDistantChecker()
    
        # Создайте примеры списков ID
        list1 = [8193, 29, 8226, 14007, 99999, 5]  # Добавил 99999 которого нет в DataFrame, чтобы протестировать исключение и 5 для создания пустого списка
        list2 = [16386, 18, 19, 80847, 10, 11, 12]  # Добавил 99999 которого нет в DataFrame, чтобы протестировать исключение
    
        # Вызовите функцию
        mapping = create_pf_bayut_mapping(list1, list2, pf_buildings_df, bayut_buildings_df, distant_checker)
    
        # Распечатайте результат
        print("Словарь соответствий:", mapping)
    

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

    • Временный список bayut_matches: Вместо непосредственного добавления в my_dict[pf], теперь соответствия bayut сначала добавляются во временный список bayut_matches.
    • Условное добавление в my_dict: После завершения внутреннего цикла, проверяется, не пуст ли список bayut_matches ( if bayut_matches:). Только если в списке есть хотя бы один элемент, пара pf: bayut_matches добавляется в my_dict. Это гарантирует, что в конечном словаре не будет ключей pf, значения которых являются пустыми списками.
    • Описание в docstring: Добавлено описание в docstring о том, что пустые списки удаляются.
    • Добавлен пример использования: Обновил пример использования, добавив значение 5 в list1, чтобы проверить случай, когда список bayut_matches останется пустым.

    Этот код теперь правильно удаляет записи с пустыми списками bayut из результирующего словаря, сохраняя при этом все существующие обработки ошибок и индикатор прогресса.

  7. User

    new_bayut_ids_with_empty_pf = [bayut_id for bayut_id in bayut_ids_with_empty_pf if bayut_id not in pf_bayut_mapping.values()] new_missing_pf_ids = [pf_id for pf_id in missing_pf_ids if pf_id not in pf_bayut_mapping.keys()]

    ValueError Traceback (most recent call last) Cell In[200], line 2 1 new_bayut_ids_with_empty_pf = [bayut_id for bayut_id in bayut_ids_with_empty_pf if ----> 2 bayut_id not in pf_bayut_mapping.values()] 3 new_missing_pf_ids = [pf_id for pf_id in missing_pf_ids if pf_id not in pf_bayut_mapping.keys()]

    ValueError: The truth value of an array with more than one element is ambiguous. Use a.any() or a.all()

  8. Assistant

    Ошибка "ValueError: The truth value of an array with more than one element is ambiguous" возникает, когда вы пытаетесь использовать массив NumPy (или подобный объект) в логическом контексте, например, в условии if. Python не знает, следует ли считать весь массив True или False.

    В вашем случае проблема, скорее всего, в том, что pf_bayut_mapping.values() возвращает не просто список значений, а массив NumPy или pandas Series. Когда вы делаете bayut_id not in pf_bayut_mapping.values(), Python не может однозначно определить, является ли bayut_id полностью отсутствует во всех значениях в массиве.

    Чтобы решить эту проблему, нужно явно проверить, содержит ли массив pf_bayut_mapping.values() значение bayut_id. Вот как можно это сделать:

    new_bayut_ids_with_empty_pf = [bayut_id for bayut_id in bayut_ids_with_empty_pf if
                                   bayut_id not in [val for sublist in pf_bayut_mapping.values() for val in sublist]]
    new_missing_pf_ids = [pf_id for pf_id in missing_pf_ids if pf_id not in pf_bayut_mapping.keys()]
    

    Объяснение изменений:

    1. bayut_id not in [val for sublist in pf_bayut_mapping.values() for val in sublist]:
      • Преобразует значения pf_bayut_mapping.values(), которые являются списками, в один плоский список. Это позволяет правильно проверить, отсутствует ли bayut_id в каком-либо из этих списков.

    Альтернативное решение (если pf_bayut_mapping не очень большой):

    Если pf_bayut_mapping не содержит огромного количества элементов, можно просто преобразовать его значения в обычный список Python перед проверкой на вхождение:

    new_bayut_ids_with_empty_pf = [bayut_id for bayut_id in bayut_ids_with_empty_pf if
                                   bayut_id not in [item for sublist in list(pf_bayut_mapping.values()) for item in sublist]]
    new_missing_pf_ids = [pf_id for pf_id in missing_pf_ids if pf_id not in pf_bayut_mapping.keys()]
    

    Что касается new_missing_pf_ids:

    Вторая строка кода, вероятно, работает правильно, потому что pf_bayut_mapping.keys() возвращает итерируемый объект (похожий на множество), для которого операция in определена корректно. То есть, Python может эффективно проверить, есть ли ключ pf_id в словаре pf_bayut_mapping.

    Пример:

    Предположим:

    pf_bayut_mapping = {
        1: [10, 11],
        2: [12],
        3: []
    }
    bayut_ids_with_empty_pf = [10, 11, 12, 13, 14]
    missing_pf_ids = [1, 2, 3, 4, 5]
    

    После применения предложенного решения:

    • new_bayut_ids_with_empty_pf будет [13, 14] (потому что 10, 11 и 12 уже есть в pf_bayut_mapping.values())
    • new_missing_pf_ids будет [4, 5] (потому что 1, 2 и 3 уже есть в pf_bayut_mapping.keys())

    Важно:

    Помните, что если списки pf_bayut_mapping.values() очень большие, то создание плоского списка может быть не очень эффективным. Если это так, рассмотрите другие подходы, например, использование множеств (sets) для более быстрого поиска.

  9. User

    в маппинге такое содрежание: np.int64(14990): [np.int64(17643)], np.int64(15037): [np.int64(20869), np.int64(20871), np.int64(20874)], np.int64(15042): [np.int64(17073), np.int64(17452)], np.int64(15044): [np.int64(18646)],

  10. Assistant

    Понятно. Тогда становится ясным, почему возникает ошибка ValueError. Проблема в том, что в словаре pf_bayut_mapping ключи и значения - это объекты np.int64, а не обычные Python int. Это означает, что вам нужно сравнивать с np.int64 значениями. Также нужно учесть, что значения - это списки. Вот исправленный код:

    import numpy as np
    
    new_bayut_ids_with_empty_pf = [bayut_id for bayut_id in bayut_ids_with_empty_pf if
                                   not any(bayut_id in sublist for sublist in pf_bayut_mapping.values())]
    new_missing_pf_ids = [pf_id for pf_id in missing_pf_ids if np.int64(pf_id) not in pf_bayut_mapping.keys()]
    

    Объяснение исправлений:

    1. bayut_id not in sublist for sublist in pf_bayut_mapping.values() заменено на not any(bayut_id in sublist for sublist in pf_bayut_mapping.values()): Этот фрагмент кода перебирает все подсписки в значениях pf_bayut_mapping, и проверяет, содержится ли bayut_id в каком-либо из них. any() вернет True, если bayut_id найден хотя бы в одном подсписке, и False в противном случае. not any(...) инвертирует результат, давая нам нужный результат. Важно: Это решение предполагает, что bayut_ids_with_empty_pf содержит обычные int, а в значениях pf_bayut_mapping содержатся np.int64. Если bayut_ids_with_empty_pf содержит np.int64, то нужно кастовать: not any(np.int64(bayut_id) in sublist for sublist in pf_bayut_mapping.values()).

    2. pf_id not in pf_bayut_mapping.keys() заменено на np.int64(pf_id) not in pf_bayut_mapping.keys(): Преобразует pf_id в np.int64, чтобы тип данных соответствовал типам ключей в pf_bayut_mapping. Без этого преобразования сравнение pf_id not in pf_bayut_mapping.keys() может давать неверный результат, потому что Python считает объекты разных типов разными.

    Почему это важно:

    NumPy (np.int64) и стандартные типы Python (int) - это разные типы данных, даже если они представляют одно и то же числовое значение. Операторы in и not in выполняют сравнение типов в дополнение к значению. Если типы не совпадают, сравнение может быть некорректным.

    Полный пример (с учетом того, что bayut_ids_with_empty_pf и missing_pf_ids тоже могут содержать np.int64):

    import numpy as np
    
    # Допустим, у вас есть вот такой mapping (пример):
    pf_bayut_mapping = {
        np.int64(14990): [np.int64(17643)],
        np.int64(15037): [np.int64(20869), np.int64(20871), np.int64(20874)],
        np.int64(15042): [np.int64(17073), np.int64(17452)],
        np.int64(15044): [np.int64(18646)],
    }
    
    bayut_ids_with_empty_pf = [17643, 20869, 20871, 12345]  # Пример
    missing_pf_ids = [14990, 15037, 99999]  # Пример
    
    new_bayut_ids_with_empty_pf = [bayut_id for bayut_id in bayut_ids_with_empty_pf if
                                   not any(np.int64(bayut_id) in sublist for sublist in pf_bayut_mapping.values())]  # Явное приведение к np.int64
    
    new_missing_pf_ids = [pf_id for pf_id in missing_pf_ids if np.int64(pf_id) not in pf_bayut_mapping.keys()]
    
    
    print("new_bayut_ids_with_empty_pf:", new_bayut_ids_with_empty_pf)
    print("new_missing_pf_ids:", new_missing_pf_ids)
    

    Вывод примера:

    new_bayut_ids_with_empty_pf: [12345]
    new_missing_pf_ids: [99999]
    

    Этот код должен правильно работать с вашим словарем, содержащим np.int64 значения. Важно: убедитесь, что вы правильно определили, какие переменные содержат объекты np.int64, и приводите к этому типу, если нужно.

  11. User

    может быть проблема в том, что в текущей реализации предполагается, что в value одно значение, а не список?

  12. Assistant

    Да, вы правы! Это очень важный момент. Я упустил это из виду, сосредоточившись на типах данных.

    Текущая реализация:

    new_bayut_ids_with_empty_pf = [bayut_id for bayut_id in bayut_ids_with_empty_pf if
                                   bayut_id not in [val for sublist in pf_bayut_mapping.values() for val in sublist]]
    

    Эта реализация предполагает, что pf_bayut_mapping.values() возвращает список списков, где каждый подсписок содержит одно значение, которое нужно сравнивать с bayut_id. На самом деле, подсписки могут содержать несколько значений.

    Решение:

    Проблема решается разворачиванием подсписков и проверкой, присутствует ли bayut_id в каком-либо из элементов этих подсписков. Я уже исправил код в предыдущем ответе, но повторю здесь для ясности:

    import numpy as np
    
    new_bayut_ids_with_empty_pf = [bayut_id for bayut_id in bayut_ids_with_empty_pf if
                                   not any(np.int64(bayut_id) in sublist for sublist in pf_bayut_mapping.values())]
    new_missing_pf_ids = [pf_id for pf_id in missing_pf_ids if np.int64(pf_id) not in pf_bayut_mapping.keys()]
    

    Почему any() работает?

    Функция any() принимает итерируемый объект (в данном случае, генератор np.int64(bayut_id) in sublist for sublist in pf_bayut_mapping.values()). Она возвращает True, если хотя бы один элемент в итерируемом объекте истинный (т.е., если np.int64(bayut_id) in sublist возвращает True хотя бы для одного sublist), и False, если все элементы ложные.

    Таким образом, not any(...) возвращает True только в том случае, если bayut_id не найден ни в одном из подсписков в pf_bayut_mapping.values().

    Подытожим:

    • Проблема была в том, что pf_bayut_mapping.values() содержит списки списков.
    • Решение состоит в том, чтобы перебрать все подсписки и проверить, присутствует ли bayut_id хотя бы в одном из них.
    • Функция any() обеспечивает удобный способ сделать это.
    • Важно приводить типы к np.int64, чтобы сравнение было корректным.

    Спасибо, что обратили мое внимание на эту ошибку!

  13. User

    давай оставим текущую реализацию (до исправлений), просто преобразуем новый словарь в формат ключ: одно значение т.е. развернем ключ: список в одиночные виды

  14. Assistant
    import numpy as np
    
    def flatten_mapping(pf_bayut_mapping: dict[np.int64, list[np.int64]]) -> dict[np.int64, np.int64]:
        """
        Преобразует словарь, где ключи связаны со списками значений, в словарь, где ключи связаны с единичными значениями.
        Если для ключа существует несколько значений, создаются отдельные записи для каждого значения.
    
        Args:
            pf_bayut_mapping: Словарь, где ключи - np.int64, а значения - списки np.int64.
    
        Returns:
            Словарь, где ключи - np.int64, а значения - единичные np.int64.
        """
        flattened_mapping = {}
        for pf_id, bayut_ids in pf_bayut_mapping.items():
            for bayut_id in bayut_ids:
                flattened_mapping[pf_id] = bayut_id  # Если ключ повторяется, перезаписываем его.
    
        return flattened_mapping
    
    
    # Пример использования:
    pf_bayut_mapping = {
        np.int64(14990): [np.int64(17643)],
        np.int64(15037): [np.int64(20869), np.int64(20871), np.int64(20874)],
        np.int64(15042): [np.int64(17073), np.int64(17452)],
        np.int64(15044): [np.int64(18646)],
    }
    
    flattened_mapping = flatten_mapping(pf_bayut_mapping)
    print(flattened_mapping)
    
    

    Объяснение:

    1. Перебор словаря: Цикл for pf_id, bayut_ids in pf_bayut_mapping.items(): перебирает все ключи и значения (в виде списков) в исходном словаре.
    2. Перебор списка: Вложенный цикл for bayut_id in bayut_ids: перебирает все элементы в списке значений для каждого ключа pf_id.
    3. Создание новых записей: Внутри вложенного цикла создается новая запись в flattened_mapping с ключом pf_id и значением bayut_id.
    4. Перезапись ключей: Важно отметить, что если один и тот же ключ pf_id встречается несколько раз (потому что в исходном словаре у него был список из нескольких значений), то он будет перезаписан. В результате в flattened_mapping останется только последнее значение bayut_id, связанное с этим ключом. Если вам нужно сохранить все соответствия, этот метод не подойдет. Нужно собирать в список.

    Альтернативный вариант: сохранение всех соответствий (один-ко-многим в списке):

    Если вам нужно сохранить все соответствия, а не просто перезаписывать ключи, то можно создать словарь, где значения - списки:

    import numpy as np
    
    def flatten_mapping_list(pf_bayut_mapping: dict[np.int64, list[np.int64]]) -> dict[np.int64, list[np.int64]]:
        """
        Преобразует словарь, где ключи связаны со списками значений, в словарь, где ключи связаны со списками единичных значений.
    
        Args:
            pf_bayut_mapping: Словарь, где ключи - np.int64, а значения - списки np.int64.
    
        Returns:
            Словарь, где ключи - np.int64, а значения - списки, содержащие по одному np.int64.
        """
        flattened_mapping = {}
        for pf_id, bayut_ids in pf_bayut_mapping.items():
            flattened_mapping[pf_id] = [bayut_id for bayut_id in bayut_ids]  # Создаем список из значений
    
        return flattened_mapping
    
    pf_bayut_mapping = {
        np.int64(14990): [np.int64(17643)],
        np.int64(15037): [np.int64(20869), np.int64(20871), np.int64(20874)],
        np.int64(15042): [np.int64(17073), np.int64(17452)],
        np.int64(15044): [np.int64(18646)],
    }
    
    flattened_mapping = flatten_mapping_list(pf_bayut_mapping)
    print(flattened_mapping)
    

    Этот вариант просто копирует списки значений из исходного словаря в новый словарь. Он не "разворачивает" структуру, а сохраняет ее как есть.

    Выбор реализации:

    Выберите ту реализацию, которая соответствует вашим потребностям. Если вам нужно только одно значение bayut_id для каждого pf_id, используйте первый вариант (flatten_mapping). Если вам нужно сохранить все соответствия, используйте второй вариант (flatten_mapping_list).

  15. User

    Нужно здесь добдавить больше информативности точкам: вывести название, координаты и тп

    for pf_id in new_missing_pf_ids:
        # Получаем данные для pf_id
        pf_data = pf_buildings_df[pf_buildings_df["id"] == pf_id]
        if not pf_data.empty:
            lat = pf_data["lat"].values[0]
            lon = pf_data["lon"].values[0]
            folium.Circle(
                location=[lat, lon],
                radius=10,
                popup=f"PFID: {pf_id}",
                color="green",
                fill=True,
                fill_color="green",
                fill_opacity=1.0,
            ).add_to(m)
    #%% md
    Наносим точки для bayut_id
    #%%
    for bayut_id in new_bayut_ids_with_empty_pf:
        # Получаем данные для bayut_id
        bayut_data = true_connected_df[true_connected_df["externalID"] == bayut_id]
        if not bayut_data.empty:
            lat = bayut_data["lat"].values[0]  # Предполагается, что вы добавили lat в true_connected_df
            lon = bayut_data["lon"].values[0]  # Предполагается, что вы добавили lon в true_connected_df
            folium.Circle(
                location=[lat, lon],
                radius=10,
                popup=f"Bayut ID: {bayut_id}",
                color="orange",
                fill=True,
                fill_color="orange",
                fill_opacity=1.0,
            ).add_to(m)
    #%% md
    Наносим пары точек из pf_bayut_mapping
    #%%
    for pf_id, bayut_id in pf_bayut_mapping_single.items():
        # Получаем данные для pf_id
        pf_data = pf_buildings_df[pf_buildings_df["id"] == pf_id]
        if not pf_data.empty:
            pf_lat = pf_data["lat"].values[0]
            pf_lon = pf_data["lon"].values[0]
            folium.Circle(
                location=[pf_lat, pf_lon],
                radius=10,
                popup=f"PFID: {pf_id}",
                color="red",
                fill=True,
                fill_color="red",
                fill_opacity=1.0,
            ).add_to(m)
    
        # Получаем данные для bayut_id
        bayut_data = true_connected_df[true_connected_df["externalID"] == bayut_id]
        if not bayut_data.empty:
            bayut_lat = bayut_data["lat"].values[0]  # Предполагается, что вы добавили lat в true_connected_df
            bayut_lon = bayut_data["lon"].values[0]  # Предполагается, что вы добавили lon в true_connected_df
            folium.Circle(
                location=[bayut_lat, bayut_lon],
                radius=10,
                popup=f"Bayut ID: {bayut_id}",
                color="orange",
                fill=True,
                fill_color="orange",
                fill_opacity=1.0,
            ).add_to(m)
    
            # Наносим линию между точками
            folium.PolyLine(
                locations=[[pf_lat, pf_lon], [bayut_lat, bayut_lon]],
                color="black",
                weight=2
            ).add_to(m)
    

    За основу можешь взять информацию точек из этого примера:

    for _, row in tqdm(bayut_buildings_df.iterrows(), total=len(bayut_buildings_df),
                       desc="Bayut Map Points"):  # Добавим tqdm
        # Проверка на NaN координаты перед использованием
        if pd.isna(row['lat']) or pd.isna(row['lon']):
            continue  # Пропускаем строки с невалидными координатами
    
        lat, lon = row['lat'], row['lon']
        name = row.get('name', 'N/A')  # Безопасное получение значений
        type_ = row.get('type', 'N/A')  # Используем ваше имя переменной type_
        external_id = row.get('externalID', 'N/A')
        aliases = row.get('aliases', [])
        pf_id = row.get('PFID', None)  # Используем get для обработки возможного отсутствия колонки
        pf_name = row.get('PF_Name', 'N/A')
    
        # Определяем цвет маркера Bayut (независимо от объединения)
        if type_ == 'condo-building':
            bayut_marker_color = 'green'
        elif type_ == 'neighbourhood':
            bayut_marker_color = 'orange'
        else:
            bayut_marker_color = 'yellow'
    
        # Формируем popup
        popup_html = f"""
        <b>Bayut Info</b><br>
        --------------------<br>
        <b>Name:</b> {name}<br>
        <b>Type:</b> {type_}<br>
        <b>ExtID:</b> {external_id}<br>
        <b>Aliases:</b> {aliases}<br>
        <b>PFID:</b> {pf_id if pd.notna(pf_id) else '<i>None</i>'}<br>
        <b>PF Name:</b> {pf_name if pd.notna(pf_name) else '<i>None</i>'}
        """
        popup = folium.Popup(popup_html, max_width=350)
    
        # --- Логика добавления в группы ---
        if pd.notna(pf_id):
            # === Это объединенная точка ===
            tooltip_combined = f"✅ Объед.: {name} (Тип: {type_})"
            # 1. Добавляем большой зеленый круг в группу объединенных
            folium.Circle(
                location=[lat, lon],
                radius=10,  # Размер круга можно настроить
                color='green',  # Всегда зеленый для объединенных
                fill=True,
                fill_color='green',
                fill_opacity=0.3,
                tooltip=tooltip_combined  # Добавим tooltip
            ).add_to(fg_combined_bayut)  # <-- ИЗМЕНЕНО: Добавляем в группу fg_combined_bayut
    
            # 2. Добавляем основной маркер (с цветом по типу) в группу объединенных
            folium.CircleMarker(
                location=[lat, lon],
                radius=5,
                color=bayut_marker_color,  # Цвет по типу
                fill=True,
                fill_color=bayut_marker_color,
                fill_opacity=0.7,
                popup=popup,  # Popup добавляем сюда
                tooltip=tooltip_combined  # И сюда
            ).add_to(fg_combined_bayut)  # <-- ИЗМЕНЕНО: Добавляем в группу fg_combined_bayut
        else:
            # === Это НЕ объединенная точка Bayut ===
            tooltip_uncombined = f"❓ Bayut Необъед.: {name} (Тип: {type_})"
            # Добавляем ТОЛЬКО маркер (с цветом по типу) в группу необъединенных Bayut
            folium.CircleMarker(
                location=[lat, lon],
                radius=5,
                color=bayut_marker_color,  # Цвет по типу
                fill=True,
                fill_color=bayut_marker_color,
                fill_opacity=0.7,
                popup=popup,  # Popup добавляем сюда
                tooltip=tooltip_uncombined
            ).add_to(fg_uncombined_bayut)  # <-- ИЗМЕНЕНО: Добавляем в группу fg_uncombined_bayut
    # --- КОНЕЦ ИЗМЕНЕННОГО ЦИКЛА ---
    # --- ИЗМЕНЕННЫЙ ЦИКЛ ---
    print("Обработка точек PF для карты...")  # Добавим вывод
    # Получаем set ID перед циклом для эффективности
    # Убедимся, что PFID в true_connect_df - это числа (если возможно)
    try:
        matched_pf_ids_set = set(true_connect_df['PFID'].dropna().astype(int))
    except ValueError:
        print("Предупреждение: Не удалось привести PFID к int, возможны ошибки сравнения.")
        matched_pf_ids_set = set(true_connect_df['PFID'].dropna())
    
    # Убедимся что координаты в pf_dubai_locations_df существуют и не NaN
    if 'lat' not in pf_dubai_locations_df.columns or pf_dubai_locations_df['lat'].isnull().any():
        pf_dubai_locations_df['lat'] = pf_dubai_locations_df['coordinates'].apply(
            lambda x: x.get('lat') if isinstance(x, dict) else None)
    if 'lon' not in pf_dubai_locations_df.columns or pf_dubai_locations_df['lon'].isnull().any():
        pf_dubai_locations_df['lon'] = pf_dubai_locations_df['coordinates'].apply(
            lambda x: x.get('lon') if isinstance(x, dict) else None)
    pf_map_df = pf_dubai_locations_df.dropna(subset=['lat', 'lon', 'id']).copy()
    # Приводим ID к int для сравнения с set
    try:
        pf_map_df['id'] = pf_map_df['id'].astype(int)
    except ValueError:
        print("Предупреждение: Не удалось привести id PF к int, возможны ошибки сравнения.")
        pf_map_df['id'] = pd.to_numeric(pf_map_df['id'], errors='coerce')
        pf_map_df.dropna(subset=['id'], inplace=True)  # Удаляем те, что не смогли привестись
    
    for _, row in tqdm(pf_map_df.iterrows(), total=len(pf_map_df), desc="PF Map Points"):
        pf_id = row['id']
        # Проверяем, что этот ID *не* входит в число объединенных
        if pf_id not in matched_pf_ids_set:
            lat, lon = row['lat'], row['lon']
            name = row.get('name', 'N/A')
            location_type = row.get('location_type', 'N/A')
    
            if location_type == 'TOWER':
                color = 'purple'
            elif location_type == 'SUBCOMMUNITY':
                color = 'gray'
            else:
                color = 'black'
    
            popup_html = f"<b>PF Info (Необъед.)</b><br>Name: {name}<br>PF_ID: {pf_id}<br>Type: {location_type}"
            popup = folium.Popup(popup_html, max_width=300)
            tooltip = f"❓ PF Необъед.: {name} (PFID: {pf_id})"
    
            folium.CircleMarker(
                location=[lat, lon],
                radius=5,
                color=color,
                fill=True,
                fill_color=color,
                fill_opacity=0.7,
                popup=popup,  # Используем созданный popup
                tooltip=tooltip  # Добавляем tooltip
            ).add_to(fg_uncombined_pf)  # <-- ИЗМЕНЕНО: Добавляем в группу fg_uncombined_pf
    # --- КОНЕЦ ИЗМЕНЕННОГО ЦИКЛА ---
    
  16. Assistant
    import folium
    import pandas as pd
    import numpy as np
    from tqdm import tqdm  # Import tqdm
    
    def add_information_to_map(m, new_missing_pf_ids, new_bayut_ids_with_empty_pf, pf_bayut_mapping_single, pf_buildings_df, true_connected_df):
        """
        Добавляет информативные точки на карту Folium для PFID и Bayut ID.
    
        Args:
            m: Объект карты Folium.
            new_missing_pf_ids: Список PFID, отсутствующих в маппинге.
            new_bayut_ids_with_empty_pf: Список Bayut ID с пустым PF в маппинге.
            pf_bayut_mapping_single: Словарь с маппингом PFID -> Bayut ID.
            pf_buildings_df: DataFrame с информацией о PFID.
            true_connected_df: DataFrame с информацией о Bayut ID.
        """
    
        # Helper function to create the popup
        def create_popup_html(data, id_type):
            if id_type == "PF":
                name = data.get('name', 'N/A')
                location_type = data.get('location_type', 'N/A')
                pf_id = data.get('id', 'N/A')
                lat = data.get('lat', 'N/A')
                lon = data.get('lon', 'N/A')
    
                popup_html = f"""
                <b>PF Info</b><br>
                --------------------<br>
                <b>Name:</b> {name}<br>
                <b>PF_ID:</b> {pf_id}<br>
                <b>Type:</b> {location_type}<br>
                <b>Lat:</b> {lat}<br>
                <b>Lon:</b> {lon}
                """
            elif id_type == "Bayut":
                name = data.get('name', 'N/A')
                type_ = data.get('type', 'N/A')
                external_id = data.get('externalID', 'N/A')
                lat = data.get('lat', 'N/A')
                lon = data.get('lon', 'N/A')
                aliases = data.get('aliases', 'N/A')
                popup_html = f"""
                <b>Bayut Info</b><br>
                --------------------<br>
                <b>Name:</b> {name}<br>
                <b>Type:</b> {type_}<br>
                <b>ExtID:</b> {external_id}<br>
                <b>Lat:</b> {lat}<br>
                <b>Lon:</b> {lon}<br>
                <b>Aliases:</b> {aliases}
                """
    
            return popup_html
    
        # --- PF IDs, отсутствующие в маппинге ---
        print("Добавление точек PFID, отсутствующих в маппинге...")
        for pf_id in tqdm(new_missing_pf_ids, desc="Missing PFIDs"):
            try:
                pf_data = pf_buildings_df[pf_buildings_df["id"] == pf_id].iloc[0].to_dict()  # Get the first row as a dictionary
                lat = pf_data["lat"]
                lon = pf_data["lon"]
    
                popup_html = create_popup_html(pf_data, "PF")
                popup = folium.Popup(popup_html, max_width=350)
    
                folium.CircleMarker(
                    location=[lat, lon],
                    radius=5,
                    popup=popup,
                    color="green",
                    fill=True,
                    fill_color="green",
                    fill_opacity=0.7
                ).add_to(m)
            except IndexError:
                print(f"Предупреждение: PFID {pf_id} не найден в pf_buildings_df.")
    
        # --- Bayut IDs с пустыми PF ---
        print("Добавление точек Bayut ID с пустым PF...")
        for bayut_id in tqdm(new_bayut_ids_with_empty_pf, desc="Bayut IDs w/ Empty PF"):
            try:
                bayut_data = true_connected_df[true_connected_df["externalID"] == bayut_id].iloc[0].to_dict() # Get the first row as a dictionary
                lat = bayut_data["lat"]
                lon = bayut_data["lon"]
    
                popup_html = create_popup_html(bayut_data, "Bayut")
                popup = folium.Popup(popup_html, max_width=350)
    
                folium.CircleMarker(
                    location=[lat, lon],
                    radius=5,
                    popup=popup,
                    color="orange",
                    fill=True,
                    fill_color="orange",
                    fill_opacity=0.7
                ).add_to(m)
            except IndexError:
                print(f"Предупреждение: Bayut ID {bayut_id} не найден в true_connected_df.")
    
        # --- Пары точек из pf_bayut_mapping ---
        print("Добавление пар точек из pf_bayut_mapping...")
        for pf_id, bayut_id in tqdm(pf_bayut_mapping_single.items(), desc="Mapping Pairs"):
            try:
                pf_data = pf_buildings_df[pf_buildings_df["id"] == pf_id].iloc[0].to_dict() # Get the first row as a dictionary
                pf_lat = pf_data["lat"]
                pf_lon = pf_data["lon"]
    
                bayut_data = true_connected_df[true_connected_df["externalID"] == bayut_id].iloc[0].to_dict() # Get the first row as a dictionary
                bayut_lat = bayut_data["lat"]
                bayut_lon = bayut_data["lon"]
    
                # PF Point
                popup_html_pf = create_popup_html(pf_data, "PF")
                popup_pf = folium.Popup(popup_html_pf, max_width=350)
    
                folium.CircleMarker(
                    location=[pf_lat, pf_lon],
                    radius=5,
                    popup=popup_pf,
                    color="red",
                    fill=True,
                    fill_color="red",
                    fill_opacity=0.7
                ).add_to(m)
    
                # Bayut Point
                popup_html_bayut = create_popup_html(bayut_data, "Bayut")
                popup_bayut = folium.Popup(popup_html_bayut, max_width=350)
    
                folium.CircleMarker(
                    location=[bayut_lat, bayut_lon],
                    radius=5,
                    popup=popup_bayut,
                    color="blue",
                    fill=True,
                    fill_color="blue",
                    fill_opacity=0.7
                ).add_to(m)
    
                # Line
                folium.PolyLine(
                    locations=[[pf_lat, pf_lon], [bayut_lat, bayut_lon]],
                    color="black",
                    weight=2
                ).add_to(m)
            except IndexError:
                print(f"Предупреждение: PFID {pf_id} или Bayut ID {bayut_id} не найден в соответствующем DataFrame.")
        return m
    
    # Пример использования (замените на ваши данные и объект карты folium):
    if __name__ == '__main__':
        # Создайте пример карты
        m = folium.Map(location=[37.7749, -122.4194], zoom_start=12)
    
        # Создайте примеры DataFrame (замените на ваши реальные данные)
        data_pf = {"id": [1, 2, 3], "lat": [37.7749, 37.78, 37.79], "lon": [-122.4194, -122.42, -122.43],
                   "name": ["Building A", "Building B", "Building C"], "location_type": ["TOWER", "SUBCOMMUNITY", "OTHER"]}
        data_bayut = {"externalID": [10, 11, 12], "lat": [37.7750, 37.781, 37.791], "lon": [-122.4195, -122.421, -122.431],
                      "name": ["Property X", "Property Y", "Property Z"], "type": ["condo-building", "neighbourhood", "other"],
                      "aliases": ["Alias 1", "Alias 2", "Alias 3"]}
    
        pf_buildings_df = pd.DataFrame(data_pf)
        true_connected_df = pd.DataFrame(data_bayut)
    
        # Создайте примеры списков и словаря (замените на ваши реальные данные)
        new_missing_pf_ids = [1, 4]  # 4 отсутствует в pf_buildings_df
        new_bayut_ids_with_empty_pf = [10, 13]  # 13 отсутствует в true_connected_df
        pf_bayut_mapping_single = {1: 10, 2: 11}
    
        m = add_information_to_map(m, new_missing_pf_ids, new_bayut_ids_with_empty_pf, pf_bayut_mapping_single, pf_buildings_df, true_connected_df)
        m.save("map_with_info.html")
    

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

    1. add_information_to_map function: Обернул всю логику нанесения точек на карту в функцию add_information_to_map, чтобы код был более структурированным и переиспользуемым.
    2. tqdm Добавил tqdm для отображения прогресса при итерации по new_missing_pf_ids, new_bayut_ids_with_empty_pf, и pf_bayut_mapping_single.
    3. Заменил iloc[0] и to_dict(): Заменил цепочку pf_data["lat"].values[0] на pf_data = pf_buildings_df[pf_buildings_df["id"] == pf_id].iloc[0].to_dict() для более простого доступа к данным из DataFrame, а также для сохранения всей информации о точке, а не только координат. to_dict() преобразует строку DataFrame в словарь, что упрощает доступ к полям.
    4. Обработка ошибок IndexError: Добавил блоки try...except IndexError для обработки ситуаций, когда pf_id или bayut_id не найдены в соответствующих DataFrame.
    5. Создание popup_html: Создал функцию create_popup_html для формирования HTML-кода для всплывающего окна. Это позволяет повторно использовать код и упрощает его изменение. Функция принимает данные (словарь) и тип ID ("PF" или "Bayut") в качестве аргументов и возвращает HTML-код для всплывающего окна.
    6. Более информативные всплывающие окна (popups): Переделал код, чтобы извлекать name, location_type, externalID, type, aliases, lat, и lon из DataFrame и включать их во всплывающее окно. Это делает карту гораздо более информативной. Проверьте, что эти столбцы существуют в ваших DataFrame.
    7. Более чистый код: Использовал dict.get(key, default) для безопасного извлечения значений из словаря. Если ключ не существует, возвращается default (в данном случае, 'N/A').
    8. Более четкие цвета: Использовал color и fill_color для указания цветов точек. Изменил цвет точек Bayut на синий.
    9. Пример использования: Добавил пример использования с фиктивными данными.
    10. Docstring: Добавил docstring для описания функции.

    Важные моменты:

    • Убедитесь, что столбцы name, location_type, externalID, type, aliases, lat, и lon существуют в ваших DataFrame (pf_buildings_df и true_connected_df).
    • Замените фиктивные данные в примере использования на ваши реальные данные.
    • Настройте стили точек (размер, цвет, прозрачность) по своему вкусу.
    • Замените координаты в folium.Map(location=[37.7749, -122.4194], zoom_start=12) на координаты вашего региона.

    Этот код предоставляет более информативные точки на вашей карте Folium и помогает лучше понимать ваши данные.

  17. User

    надо еще написать функцию, которая принимает на вход map и сохраняет его в json

  18. Assistant

    Хранить карту Folium непосредственно в формате JSON проблематично, поскольку карта Folium - это интерактивный HTML-документ, который содержит JavaScript и другие ресурсы. JSON, с другой стороны, предназначен для хранения простых структур данных. Попытка сериализовать объект Folium Map в JSON приведет к сложной и, вероятно, бесполезной строке JSON.

    Тем не менее, можно сохранить данные, используемые для создания карты, в формате JSON. Например, если вы хотите сохранить координаты, идентификаторы и другие атрибуты точек, которые вы наносите на карту, это можно сделать. Однако интерактивная карта с зумом, слоями и т.д. не будет сохранена.

    Вот как можно сохранить данные карты в JSON (а не саму карту):

    import json
    import pandas as pd
    import numpy as np
    
    def save_map_data_to_json(new_missing_pf_ids, new_bayut_ids_with_empty_pf, pf_bayut_mapping_single, pf_buildings_df, true_connected_df, filename="map_data.json"):
        """
        Сохраняет данные, используемые для создания карты, в формате JSON.
    
        Args:
            new_missing_pf_ids: Список PFID, отсутствующих в маппинге.
            new_bayut_ids_with_empty_pf: Список Bayut ID с пустым PF в маппинге.
            pf_bayut_mapping_single: Словарь с маппингом PFID -> Bayut ID.
            pf_buildings_df: DataFrame с информацией о PFID.
            true_connected_df: DataFrame с информацией о Bayut ID.
            filename: Имя файла JSON для сохранения данных.
        """
    
        map_data = {
            "missing_pf_ids": [],
            "bayut_ids_with_empty_pf": [],
            "mapping_pairs": []
        }
    
        # Extract data for missing PF IDs
        for pf_id in new_missing_pf_ids:
            try:
                pf_data = pf_buildings_df[pf_buildings_df["id"] == pf_id].iloc[0].to_dict()
                map_data["missing_pf_ids"].append(pf_data)
            except IndexError:
                print(f"Предупреждение: PFID {pf_id} не найден в pf_buildings_df.")
    
        # Extract data for Bayut IDs with empty PF
        for bayut_id in new_bayut_ids_with_empty_pf:
            try:
                bayut_data = true_connected_df[true_connected_df["externalID"] == bayut_id].iloc[0].to_dict()
                map_data["bayut_ids_with_empty_pf"].append(bayut_data)
            except IndexError:
                print(f"Предупреждение: Bayut ID {bayut_id} не найден в true_connected_df.")
    
        # Extract data for mapping pairs
        for pf_id, bayut_id in pf_bayut_mapping_single.items():
            try:
                pf_data = pf_buildings_df[pf_buildings_df["id"] == pf_id].iloc[0].to_dict()
                bayut_data = true_connected_df[true_connected_df["externalID"] == bayut_id].iloc[0].to_dict()
                map_data["mapping_pairs"].append({"pf": pf_data, "bayut": bayut_data})
            except IndexError:
                print(f"Предупреждение: PFID {pf_id} или Bayut ID {bayut_id} не найден в соответствующем DataFrame.")
    
        # Save to JSON file
        with open(filename, "w") as f:
            json.dump(map_data, f, indent=4, default=convert)
    
    def convert(o):
        if isinstance(o, np.int64): return int(o)
        raise TypeError
    
    # Пример использования (замените на ваши данные)
    if __name__ == '__main__':
        # Создайте примеры DataFrame (замените на ваши реальные данные)
        data_pf = {"id": [1, 2, 3], "lat": [37.7749, 37.78, 37.79], "lon": [-122.4194, -122.42, -122.43],
                   "name": ["Building A", "Building B", "Building C"], "location_type": ["TOWER", "SUBCOMMUNITY", "OTHER"]}
        data_bayut = {"externalID": [10, 11, 12], "lat": [37.7750, 37.781, 37.791], "lon": [-122.4195, -122.421, -122.431],
                      "name": ["Property X", "Property Y", "Property Z"], "type": ["condo-building", "neighbourhood", "other"],
                      "aliases": ["Alias 1", "Alias 2", "Alias 3"]}
    
        pf_buildings_df = pd.DataFrame(data_pf)
        true_connected_df = pd.DataFrame(data_bayut)
    
        # Создайте примеры списков и словаря (замените на ваши реальные данные)
        new_missing_pf_ids = [1, 4]  # 4 отсутствует в pf_buildings_df
        new_bayut_ids_with_empty_pf = [10, 13]  # 13 отсутствует в true_connected_df
        pf_bayut_mapping_single = {1: 10, 2: 11}
    
        save_map_data_to_json(new_missing_pf_ids, new_bayut_ids_with_empty_pf, pf_bayut_mapping_single, pf_buildings_df, true_connected_df)
    

    Объяснение:

    1. Структура данных JSON: Функция создает словарь map_data с тремя ключами: "missing_pf_ids", "bayut_ids_with_empty_pf", и "mapping_pairs". Каждый из этих ключей содержит список словарей. Каждый словарь представляет собой строку из DataFrame, преобразованную в словарь с помощью to_dict().
    2. Извлечение данных: Циклы перебирают ваши списки (new_missing_pf_ids, new_bayut_ids_with_empty_pf) и словарь (pf_bayut_mapping_single), извлекают соответствующие строки из DataFrame и добавляют их в соответствующие списки в map_data.
    3. Обработка IndexError: Как и раньше, функция обрабатывает исключение IndexError, если идентификатор не найден в DataFrame.
    4. Сохранение в JSON: Функция использует json.dump() для сохранения словаря map_data в файл JSON. Аргумент indent=4 добавляет отступы для улучшения читаемости. default=convert нужен для обработки типа данных np.int64
    5. Функция convert(): Добавил функцию convert(o), которая обрабатывает преобразование np.int64 в обычный int. Это необходимо, потому что json.dump() по умолчанию не знает, как сериализовать объекты NumPy.

    Как использовать сохраненные данные JSON:

    Чтобы использовать данные JSON для воссоздания карты, вам нужно будет загрузить JSON-файл, прочитать данные и затем использовать их для повторного создания карты Folium, как в вашем исходном коде.

    Пример загрузки и использования JSON-данных:

    import json
    import folium
    import pandas as pd
    
    def create_map_from_json(filename="map_data.json"):
        """
        Создает карту Folium на основе данных, сохраненных в файле JSON.
    
        Args:
            filename: Имя файла JSON, содержащего данные карты.
    
        Returns:
            Объект карты Folium.
        """
    
        with open(filename, "r") as f:
            map_data = json.load(f)
    
        # Создайте карту (замените координаты и масштаб на нужные)
        m = folium.Map(location=[37.7749, -122.4194], zoom_start=12)
    
        # Добавьте точки на карту (здесь нужно воспроизвести вашу логику добавления точек)
        # Пример:
        for pf_data in map_data["missing_pf_ids"]:
            folium.CircleMarker(
                location=[pf_data["lat"], pf_data["lon"]],
                radius=5,
                color="green",
                fill=True,
                fill_color="green",
                fill_opacity=0.7
            ).add_to(m)
    
        # И так далее для других типов точек
    
        return m
    
    # Пример использования:
    if __name__ == '__main__':
        # Предполагается, что файл map_data.json уже существует
        m = create_map_from_json()
        m.save("map_recreated_from_json.html")
    

    Важно:

    • Этот код сохраняет только данные, необходимые для создания карты. Он не сохраняет саму карту Folium в интерактивном виде.
    • Чтобы воссоздать карту, вам нужно будет написать код, который читает данные JSON и использует их для повторного добавления точек, линий и других элементов на карту Folium.
    • Структура JSON должна соответствовать структуре, которую вы используете в своем коде для добавления элементов на карту.

    Этот подход позволяет вам сохранять данные, которые вы используете для создания карты, и повторно использовать их в будущем. Однако для воссоздания полной интерактивной карты Folium потребуется больше кода.

    Если вам нужно сохранить интерактивную карту, вам следует сохранить ее в виде HTML-файла, как вы делаете в своем исходном коде. Невозможно сохранить интерактивную карту Folium в формате JSON.

  19. User

    Нет, я имел ввиду pf_bayut_mapping что бы каждый раз не выполнять обработку, просто загрузить имеющийся

  20. Assistant

    Ах, теперь понял! Вы хотите сохранить словарь pf_bayut_mapping в JSON, чтобы не вычислять его заново каждый раз. Вот как это можно сделать:

    import json
    import numpy as np
    
    def save_mapping_to_json(pf_bayut_mapping: dict[np.int64, list[np.int64]], filename="pf_bayut_mapping.json"):
        """
        Сохраняет словарь pf_bayut_mapping в файл JSON.
    
        Args:
            pf_bayut_mapping: Словарь, который нужно сохранить.
            filename: Имя файла JSON.
        """
        # Преобразуем ключи и значения в обычные типы Python, чтобы JSON мог их обработать
        # Здесь нужно преобразовать np.int64 в обычные int
        serializable_mapping = {int(k): [int(v) for v in values] for k, values in pf_bayut_mapping.items()}
    
        with open(filename, "w") as f:
            json.dump(serializable_mapping, f, indent=4)
    
    
    def load_mapping_from_json(filename="pf_bayut_mapping.json") -> dict[np.int64, list[np.int64]]:
        """
        Загружает словарь pf_bayut_mapping из файла JSON.
    
        Args:
            filename: Имя файла JSON.
    
        Returns:
            Словарь pf_bayut_mapping.
        """
        with open(filename, "r") as f:
            loaded_mapping = json.load(f)
    
        # Преобразуем ключи и значения обратно в np.int64
        # При чтении из JSON ключи и значения будут обычными int, нужно их преобразовать обратно
        pf_bayut_mapping = {np.int64(k): [np.int64(v) for v in values] for k, values in loaded_mapping.items()}
        return pf_bayut_mapping
    
    
    # Пример использования:
    if __name__ == '__main__':
        # Допустим, у вас есть вот такой mapping (пример):
        pf_bayut_mapping = {
            np.int64(14990): [np.int64(17643)],
            np.int64(15037): [np.int64(20869), np.int64(20871), np.int64(20874)],
            np.int64(15042): [np.int64(17073), np.int64(17452)],
            np.int64(15044): [np.int64(18646)],
        }
    
        # Сохраняем mapping в файл
        save_mapping_to_json(pf_bayut_mapping, "pf_bayut_mapping.json")
    
        # Загружаем mapping из файла
        loaded_mapping = load_mapping_from_json("pf_bayut_mapping.json")
    
        # Проверяем, что загруженный mapping совпадает с исходным
        print("Исходный mapping:", pf_bayut_mapping)
        print("Загруженный mapping:", loaded_mapping)
        print("Mapping совпадают:", pf_bayut_mapping == loaded_mapping)
    

    Объяснение:

    1. save_mapping_to_json(pf_bayut_mapping, filename):

      • Принимает словарь pf_bayut_mapping и имя файла.
      • Преобразование типов: Ключевой момент - перед сохранением в JSON необходимо преобразовать ключи и значения из np.int64 в обычные int. Это делается с помощью генератора словаря:
        serializable_mapping = {int(k): [int(v) for v in values] for k, values in pf_bayut_mapping.items()}
        
        Этот код перебирает все пары ключ-значение в pf_bayut_mapping, преобразует ключ k в int, перебирает все значения v в списке values и преобразует каждое значение в int. Затем он создает новый словарь serializable_mapping с преобразованными ключами и значениями.
      • Использует json.dump() для сохранения serializable_mapping в файл JSON с отступами для читаемости.
    2. load_mapping_from_json(filename):

      • Принимает имя файла JSON.
      • Использует json.load() для загрузки данных из файла JSON в словарь loaded_mapping. После загрузки ключи и значения будут иметь тип int, а не np.int64.
      • Обратное преобразование типов: После загрузки необходимо преобразовать ключи и значения обратно в np.int64. Это делается с помощью генератора словаря:
        pf_bayut_mapping = {np.int64(k): [np.int64(v) for v in values] for k, values in loaded_mapping.items()}
        
        Этот код перебирает все пары ключ-значение в loaded_mapping, преобразует ключ k в np.int64, перебирает все значения v в списке values и преобразует каждое значение в np.int64. Затем он создает новый словарь pf_bayut_mapping с преобразованными ключами и значениями.
      • Возвращает словарь pf_bayut_mapping с ключами и значениями типа np.int64.

    Пример использования:

    В примере использования показано, как сохранить словарь в файл JSON, загрузить его обратно и проверить, что загруженный словарь совпадает с исходным.

    Важно:

    • Убедитесь, что вы установили библиотеку numpy.
    • Этот код предполагает, что значения в вашем словаре являются списками, как показано в вашем примере словаря. Если значения имеют другой тип, вам нужно будет соответствующим образом изменить код преобразования типов.
    • При загрузке JSON-файла убедитесь, что файл существует и содержит правильную структуру данных.

    Этот код позволяет вам легко сохранять и загружать ваш словарь pf_bayut_mapping, что экономит время и вычислительные ресурсы, поскольку вам не нужно будет каждый раз пересчитывать словарь.

  21. User

    не обязательно функциями, просто в блокноте блок, при зап4ске которого делается бекап и загружается по новой

  22. Assistant
    import json
    import numpy as np
    
    # Имя файла для сохранения/загрузки
    filename = "pf_bayut_mapping.json"
    
    # ====================  Создание или загрузка mapping ====================
    
    try:
        # Попытка загрузить mapping из файла
        with open(filename, "r") as f:
            loaded_mapping = json.load(f)
        print(f"Mapping успешно загружен из файла {filename}")
    
        # Преобразование типов обратно в np.int64
        pf_bayut_mapping = {np.int64(k): [np.int64(v) for v in values] for k, values in loaded_mapping.items()}
    
    except FileNotFoundError:
        # Если файл не найден, создаем пустой mapping (или вычисляем его, если нужно)
        print(f"Файл {filename} не найден. Создается новый mapping.")
        pf_bayut_mapping = {}  # Или ваш код для вычисления mapping
    
    # ====================  Ваш код для работы с pf_bayut_mapping ====================
    #  ... (Здесь вставляем ваш код, который использует или модифицирует pf_bayut_mapping) ...
    #  Например:
    # pf_bayut_mapping[np.int64(999)] = [np.int64(111), np.int64(222)]
    # print("Mapping после модификации:", pf_bayut_mapping)
    
    
    # ====================  Резервное копирование (сохранение) mapping ====================
    
    # Преобразование типов в обычные Python для JSON
    serializable_mapping = {int(k): [int(v) for v in values] for k, values in pf_bayut_mapping.items()}
    
    with open(filename, "w") as f:
        json.dump(serializable_mapping, f, indent=4)
    print(f"Mapping сохранен в файл {filename}")
    
    

    Объяснение:

    1. Имя файла: Задайте имя файла JSON, в котором вы хотите хранить свой pf_bayut_mapping.
    2. Попытка загрузки:
      • Блок try...except FileNotFoundError пытается загрузить pf_bayut_mapping из файла JSON.
      • Если файл существует, он загружается, и ключи и значения преобразуются обратно в np.int64.
      • Если файл не существует (FileNotFoundError), создается пустой pf_bayut_mapping (или, если нужно, вставьте свой код для его вычисления с нуля).
    3. Ваш код: Вставьте свой код, который использует или модифицирует pf_bayut_mapping, в раздел, обозначенный комментариями.
    4. Резервное копирование (Сохранение):
      • Ключи и значения в pf_bayut_mapping преобразуются в обычные типы Python (int), чтобы их можно было сериализовать в JSON.
      • pf_bayut_mapping сохраняется в файл JSON.

    Как это работает:

    При первом запуске блокнота файл pf_bayut_mapping.json, скорее всего, не будет существовать. В этом случае будет создан пустой pf_bayut_mapping (или будет выполнен ваш код для его вычисления). Затем вы можете использовать и изменять pf_bayut_mapping в своем блокноте. В конце блокнота pf_bayut_mapping будет сохранен в файл JSON.

    При последующих запусках блокнота pf_bayut_mapping будет загружен из файла JSON, и вы сможете продолжить с того места, где остановились в прошлый раз.

    Преимущества:

    • Простота: Очень простой код, который можно легко вставить в свой блокнот.
    • Сохранение данных: Сохраняет ваш pf_bayut_mapping между запусками блокнота.

    Недостатки:

    • Ручное управление: Вы должны запускать этот блок кода каждый раз, когда хотите сделать резервную копию pf_bayut_mapping.
    • Нет версионности: Просто перезаписывает файл при каждом запуске. Если вам нужна история изменений, вам потребуется более сложная система.

    Этот подход хорошо подходит для простых случаев, когда вам просто нужно сохранить pf_bayut_mapping между запусками блокнота. Для более сложных сценариев вам могут понадобиться функции или более продвинутые методы хранения данных.

  23. User

    вот я создал pf_bayut_mapping в следующем блоке есть функция backup_mapping, если ее вызвать, она в папке ../backups создает json файл с названием переменной в следующем блоке есть функция загрузки файла из бэкап

  24. Assistant
    import json
    import numpy as np
    import os
    import inspect
    from datetime import datetime
    
    # --- Блок 1:  Создание pf_bayut_mapping (или загрузка из бэкапа, если есть) ---
    def create_or_load_mapping(backup_dir="../backups", mapping_name="pf_bayut_mapping"):
        """
        Пытается загрузить mapping из файла бэкапа. Если бэкап не найден, возвращает пустой mapping.
    
        Args:
            backup_dir: Директория для хранения бэкапов.
            mapping_name: Имя переменной (и файла бэкапа).
    
        Returns:
            Словарь pf_bayut_mapping (либо загруженный из бэкапа, либо пустой).
        """
        backup_file = os.path.join(backup_dir, f"{mapping_name}.json")
        try:
            with open(backup_file, "r") as f:
                loaded_mapping = json.load(f)
            print(f"Mapping '{mapping_name}' успешно загружен из бэкапа: {backup_file}")
            # Преобразование типов обратно в np.int64
            pf_bayut_mapping = {np.int64(k): [np.int64(v) for v in values] for k, values in loaded_mapping.items()}
            return pf_bayut_mapping
        except FileNotFoundError:
            print(f"Бэкап для '{mapping_name}' не найден. Создается новый mapping.")
            return {}  # Возвращаем пустой словарь, а не None
    
    # Создаем или загружаем pf_bayut_mapping (или другой mapping, если нужно)
    pf_bayut_mapping = create_or_load_mapping()
    
    
    # --- Блок 2:  Функция для создания бэкапа mapping ---
    def backup_mapping(mapping, backup_dir="../backups"):
        """
        Сохраняет mapping в файл JSON, используя имя переменной и текущую дату/время в имени файла.
    
        Args:
            mapping: Словарь, который нужно сохранить.
            backup_dir: Директория для хранения бэкапов.
        """
        # Получаем имя переменной, в которой хранится mapping
        frame = inspect.currentframe().f_back  # Get the caller's frame
        mapping_name = [k for k, v in frame.f_locals.items() if v is mapping][0] # Find the variable name
        if not mapping_name:
            raise ValueError("Не удалось определить имя переменной mapping.")
        # Create backup directory if it doesn't exist
        os.makedirs(backup_dir, exist_ok=True)
    
        # Create a timestamped filename
        timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
        backup_file = os.path.join(backup_dir, f"{mapping_name}_{timestamp}.json")
    
        # Convert keys and values to serializable types
        serializable_mapping = {int(k): [int(v) for v in values] for k, values in mapping.items()}
    
        with open(backup_file, "w") as f:
            json.dump(serializable_mapping, f, indent=4)
        print(f"Mapping '{mapping_name}' сохранен в бэкап: {backup_file}")
        return backup_file # Return the filename
    
    
    # --- Блок 3:  Функция для загрузки mapping из бэкапа ---
    def load_mapping_from_backup(backup_file):
        """
        Загружает mapping из указанного файла бэкапа.
    
        Args:
            backup_file: Путь к файлу бэкапа.
    
        Returns:
            Словарь pf_bayut_mapping, загруженный из файла бэкапа.
        """
        try:
            with open(backup_file, "r") as f:
                loaded_mapping = json.load(f)
            print(f"Mapping успешно загружен из файла бэкапа: {backup_file}")
    
            # Преобразование типов обратно в np.int64
            pf_bayut_mapping = {np.int64(k): [np.int64(v) for v in values] for k, values in loaded_mapping.items()}
            return pf_bayut_mapping
        except FileNotFoundError:
            print(f"Файл бэкапа не найден: {backup_file}")
            return None  # Или можно поднять исключение, если это необходимо
    
    
    # --- Пример использования:  ---
    if __name__ == "__main__":
        #  Допустим, у вас есть вот такой mapping (пример):
        # (Этот код не будет выполнен при загрузке из бэкапа)
        if not pf_bayut_mapping: # Если mapping пустой (то есть, мы его только что создали или бэкап не найден)
            pf_bayut_mapping = {
                np.int64(14990): [np.int64(17643)],
                np.int64(15037): [np.int64(20869), np.int64(20871), np.int64(20874)],
                np.int64(15042): [np.int64(17073), np.int64(17452)],
                np.int64(15044): [np.int64(18646)],
            }
    
        #  Модифицируем mapping (чтобы увидеть, что изменения сохраняются)
        pf_bayut_mapping[np.int64(999)] = [np.int64(111), np.int64(222)]
        print("Mapping после модификации:", pf_bayut_mapping)
    
    
        #  Создаем бэкап
        last_backup_file = backup_mapping(pf_bayut_mapping)
    
        #  Загружаем из бэкапа
        loaded_pf_bayut_mapping = load_mapping_from_backup(last_backup_file)
    
        if loaded_pf_bayut_mapping:
            print("Загруженный mapping из бэкапа:", loaded_pf_bayut_mapping)
            print("Mapping совпадают:", pf_bayut_mapping == loaded_pf_bayut_mapping)
        else:
            print("Не удалось загрузить mapping из бэкапа.")
    

    Объяснение и улучшения:

    1. create_or_load_mapping(backup_dir, mapping_name):

      • Эта функция теперь отвечает за инициализацию pf_bayut_mapping. Она пытается загрузить его из бэкапа. Если бэкап не найден, она возвращает пустой словарь ({}). Важно: Она не создает словарь, если бэкап не найден. Это позволяет вам создать словарь "с нуля", если это необходимо, и избежать перезаписи вашего рабочего mapping при каждом запуске.
      • mapping_name: Позволяет указать имя переменной для загрузки, что делает функцию более гибкой.
      • Функция возвращает значение.
    2. backup_mapping(mapping, backup_dir):

      • Динамическое имя файла: Создает имя файла бэкапа, используя имя переменной mapping и текущую дату и время (pf_bayut_mapping_20231027_103015.json). Это позволяет создавать несколько бэкапов и избегать перезаписи.
      • Получение имени переменной: Использует inspect для получения имени переменной, содержащей переданный словарь. Важно: Этот подход работает, только если вы передаете непосредственно переменную pf_bayut_mapping в функцию backup_mapping.
        • Функция теперь получает имя переменной, в которой хранится mapping, динамически.
        • Функция теперь создает метку времени для файла бэкапа.
      • Создание директории: Проверяет, существует ли директория backup_dir, и создает ее, если необходимо (os.makedirs(backup_dir, exist_ok=True)).
      • Возвращает имя файла: Функция возвращает имя созданного файла бэкапа, чтобы его можно было использовать для загрузки.
      • Добавлен exist_ok=True, чтобы не падало, если уже есть такая директория
      • if not mapping_name: Улучшен код для получения имени переменной, теперь выдает ValueError, если не получилось найти имя переменной (более надежно, чем предыдущий код).
    3. load_mapping_from_backup(backup_file):

      • Загружает pf_bayut_mapping из указанного файла бэкапа.
      • Обрабатывает FileNotFoundError на случай, если файл не существует.
      • Функция пытается загрузить mapping из существующего backup-файла.
    4. Пример использования:

      • В примере использования теперь сначала вызывается create_or_load_mapping() для инициализации pf_bayut_mapping. Это гарантирует, что у вас всегда будет словарь, с которым можно работать, независимо от того, существует ли бэкап или нет.
      • Код создания pf_bayut_mapping с нуля (пример) теперь помещен внутрь if not pf_bayut_mapping: , чтобы он выполнялся, только если pf_bayut_mapping был только что создан (или бэкап не был найден). Это позволяет избежать перезаписи вашего рабочего mapping каждый раз, когда вы запускаете блокнот.
      • Пример показывает, как создать бэкап, а затем загрузить из него.
      • last_backup_file: Сохраняется имя последнего созданного файла backup.

    Как использовать:

    1. Запустите блокнот: При первом запуске pf_bayut_mapping будет инициализирован как пустой словарь (или будет выполнен код для его создания с нуля).
    2. Модифицируйте pf_bayut_mapping: Добавьте, измените или удалите элементы в словаре pf_bayut_mapping.
    3. Создайте бэкап: Вызовите backup_mapping(pf_bayut_mapping) чтобы сохранить текущее состояние pf_bayut_mapping в файл JSON в директории ../backups.
    4. Перезапустите блокнот: При следующем запуске pf_bayut_mapping будет автоматически загружен из последнего файла бэкапа.

    Улучшения:

    • Обработка ошибок: Код включает обработку ошибок для случаев, когда файл бэкапа не найден.
    • Имя файла бэкапа: Имя файла бэкапа содержит имя переменной и метку времени, что позволяет создавать несколько бэкапов и легко их идентифицировать.
    • Автоматическое создание директории: Директория бэкапов создается автоматически, если она не существует.
    • Более гибкая загрузка: create_or_load_mapping позволяет указать имя переменной и директорию бэкапов.

    Этот улучшенный код предоставляет более надежный и гибкий способ управления вашим словарем pf_bayut_mapping.

  25. User

    оставь фукнционал:

    • проверить/создать ппапку ../backup
    • создать фал с любым имененм
    • если файл существует - дописать цифру
  26. Assistant
    import json
    import numpy as np
    import os
    from datetime import datetime
    
    def backup_mapping(mapping, backup_dir="../backups"):
        """
        Сохраняет mapping в файл JSON с автоинкрементом имени, если файл уже существует.
    
        Args:
            mapping: Словарь, который нужно сохранить.
            backup_dir: Директория для хранения бэкапов.
        """
    
        # Create backup directory if it doesn't exist
        os.makedirs(backup_dir, exist_ok=True)
    
        # Construct the base filename
        base_filename = "pf_bayut_mapping"  # No timestamp here
        filename = os.path.join(backup_dir, f"{base_filename}.json")
    
        # Auto-increment the filename if it already exists
        counter = 1
        while os.path.exists(filename):
            filename = os.path.join(backup_dir, f"{base_filename}_{counter}.json")
            counter += 1
    
        # Convert keys and values to serializable types
        serializable_mapping = {int(k): [int(v) for v in values] for k, values in mapping.items()}
    
        with open(filename, "w") as f:
            json.dump(serializable_mapping, f, indent=4)
        print(f"Mapping сохранен в бэкап: {filename}")
        return filename  # Return the filename for potential later use
    
    # Пример использования
    if __name__ == '__main__':
        # Пример словаря
        pf_bayut_mapping = {
            np.int64(14990): [np.int64(17643)],
            np.int64(15037): [np.int64(20869), np.int64(20871)],
        }
    
        # Создаем бэкап
        backup_file = backup_mapping(pf_bayut_mapping)
        print(f"Создан файл бэкапа: {backup_file}")
    

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

    1. Упрощенное имя файла: Убрал метку времени из базового имени файла, чтобы сосредоточиться на автоинкременте.
    2. Автоинкремент:
      • Код проверяет, существует ли файл pf_bayut_mapping.json.
      • Если он существует, то создает имя pf_bayut_mapping_1.json.
      • Если pf_bayut_mapping_1.json тоже существует, то создает pf_bayut_mapping_2.json, и так далее, пока не найдет свободное имя.
    3. Удалено определение имени переменной: Убрал код, использующий inspect, поскольку в этой версии это не требуется.
    4. Функциональность: Код делает именно то, что вы просили: он создает бэкап, и если файл с таким именем уже существует, добавляет к имени цифру.

    Как это работает:

    • Функция backup_mapping получает словарь и директорию для бэкапов.
    • Создается директория бэкапов, если она не существует.
    • Проверяется, существует ли файл с именем pf_bayut_mapping.json.
    • Если файл существует, то добавляется цифра (_1, _2, и т.д.) к имени файла, пока не будет найдено уникальное имя.
    • Словар преобразуется в JSON и сохраняется в файл.
    • Возвращается имя созданного файла.

    Как использовать:

    Просто вызовите функцию backup_mapping с вашим словарем и (необязательно) с директорией для бэкапов:

    backup_file = backup_mapping(pf_bayut_mapping)
    print(f"Файл бэкапа создан: {backup_file}")
    

    Если файл pf_bayut_mapping.json уже существует, будет создан файл с именем pf_bayut_mapping_1.json, затем pf_bayut_mapping_2.json, и так далее.

    Этот код предоставляет простой и надежный способ создания бэкапов вашего словаря с автоматическим инкрементом имени файла.

  27. User

    нужно теперь написать блок с загрузкой из бэкапа

  28. Assistant
    import json
    import numpy as np
    import os
    
    def load_mapping_from_backup(backup_dir="../backups"):
        """
        Загружает последний созданный mapping из бэкапа, используя автоинкремент имен файлов.
    
        Args:
            backup_dir: Директория для хранения бэкапов.
    
        Returns:
            Словарь pf_bayut_mapping, загруженный из файла бэкапа, или None, если бэкапы не найдены.
        """
        # Construct the base filename
        base_filename = "pf_bayut_mapping"
        filename = os.path.join(backup_dir, f"{base_filename}.json")
    
        # Check for base filename
        if os.path.exists(filename):
            files_to_check = [filename]
        else:
            files_to_check = []
    
        # Find the latest backup file with numbered suffixes
        counter = 1
        while True:
            numbered_filename = os.path.join(backup_dir, f"{base_filename}_{counter}.json")
            if os.path.exists(numbered_filename):
                files_to_check.append(numbered_filename)
                counter += 1
            else:
                break
    
        # If no backups were found, return None
        if not files_to_check:
            print("Бэкапы не найдены.")
            return None
    
        # Sort files by modification time (latest first) and get the most recent
        latest_backup_file = max(files_to_check, key=os.path.getmtime)
    
        try:
            with open(latest_backup_file, "r") as f:
                loaded_mapping = json.load(f)
            print(f"Mapping успешно загружен из файла бэкапа: {latest_backup_file}")
    
            # Преобразование типов обратно в np.int64
            pf_bayut_mapping = {np.int64(k): [np.int64(v) for v in values] for k, values in loaded_mapping.items()}
            return pf_bayut_mapping
        except FileNotFoundError:  # should not happen, but good to have
            print(f"Файл бэкапа не найден: {latest_backup_file}")
            return None
    
    # Пример использования
    if __name__ == '__main__':
        #  Загружаем mapping из бэкапа
        pf_bayut_mapping = load_mapping_from_backup()
    
        if pf_bayut_mapping:
            print("Загруженный mapping:", pf_bayut_mapping)
        else:
            print("Не удалось загрузить mapping из бэкапа.")
    

    Объяснение и особенности:

    1. Поиск последнего бэкапа:

      • Сначала проверяется наличие файла pf_bayut_mapping.json.
      • Затем ищется файлы с суффиксами pf_bayut_mapping_1.json, pf_bayut_mapping_2.json и так далее, добавляя их в список files_to_check.
      • Если файлы с суффиксами не найдены, цикл прекращается.
      • Если не найдено ни одного файла, возвращается None.
      • Важно: Если существует и pf_bayut_mapping.json и файлы с суффиксами, то в files_to_check они оба появятся.
      • Затем выбирается самый последний файл (то есть, с самым поздним временем изменения) из списка найденных файлов. Это делается с помощью max(files_to_check, key=os.path.getmtime).
    2. Загрузка из JSON:

      • Если бэкапы найдены, выполняется попытка загрузки данных из самого последнего бэкапа.
      • Если загрузка прошла успешно, то ключи и значения преобразуются обратно в np.int64, и словарь возвращается.
      • Если во время загрузки возникла ошибка (FileNotFoundError - в данном случае не должно произойти, но проверка не помешает), то возвращается None.
    3. Возвращаемое значение:

      • Функция возвращает загруженный словарь pf_bayut_mapping, если загрузка прошла успешно.
      • Если бэкапы не найдены или произошла ошибка при загрузке, функция возвращает None.

    Как использовать:

    Просто вызовите функцию load_mapping_from_backup():

    pf_bayut_mapping = load_mapping_from_backup()
    
    if pf_bayut_mapping:
        print("Mapping загружен:", pf_bayut_mapping)
        #  ... ваш код, который использует pf_bayut_mapping ...
    else:
        print("Не удалось загрузить mapping. Используется пустой mapping или будет создан новый.")
        #  ... ваш код для создания pf_bayut_mapping с нуля ...
    

    Важные моменты:

    • Обработка отсутствия бэкапов: Код явно обрабатывает ситуацию, когда бэкапы не найдены, возвращая None. Обязательно проверьте возвращаемое значение и выполните необходимые действия, если бэкап не был найден (например, создайте новый словарь).
    • Импорт os: Убедитесь, что вы импортировали модуль os.
    • Пути к файлам: Убедитесь, что пути к файлам указаны правильно.

    Этот код предоставит вам надежный механизм загрузки последнего бэкапа вашего словаря pf_bayut_mapping.

  29. User

    # for pf_id, bayut_id in pf_bayut_mapping_single.items():

    # Получаем данные для pf_id

    pf_data = pf_buildings_df[pf_buildings_df["id"] == pf_id]

    if not pf_data.empty:

    pf_lat = pf_data["lat"].values[0]

    pf_lon = pf_data["lon"].values[0]

    folium.Circle(

    location=[pf_lat, pf_lon],

    radius=10,

    popup=f"PFID: {pf_id}",

    color="red",

    fill=True,

    fill_color="red",

    fill_opacity=1.0,

    ).add_to(m)

    # Получаем данные для bayut_id

    bayut_data = true_connected_df[true_connected_df["externalID"] == bayut_id]

    if not bayut_data.empty:

    bayut_lat = bayut_data["lat"].values[0] # Предполагается, что вы добавили lat в true_connected_df

    bayut_lon = bayut_data["lon"].values[0] # Предполагается, что вы добавили lon в true_connected_df

    folium.Circle(

    location=[bayut_lat, bayut_lon],

    radius=10,

    popup=f"Bayut ID: {bayut_id}",

    color="orange",

    fill=True,

    fill_color="orange",

    fill_opacity=1.0,

    ).add_to(m)

    # Наносим линию между точками

    folium.PolyLine(

    locations=[[pf_lat, pf_lon], [bayut_lat, bayut_lon]],

    color="black",

    weight=2

    ).add_to(m)

    for pf_id, bayut_id in pf_bayut_mapping_single.items(): # PF pf_data = pf_buildings_df[pf_buildings_df["id"] == pf_id] if not pf_data.empty: pf_lat = pf_data["lat"].values[0] pf_lon = pf_data["lon"].values[0] pf_name = pf_data["name"].values[0] if "name" in pf_data else "N/A" pf_type = pf_data["location_type"].values[0] if "location_type" in pf_data else "N/A" pf_aliases = pf_data["aliases"].values[0] if "aliases" in pf_data else "N/A"

        popup_html_pf = f"""
        <b>PF Info (Объед.)</b><br>
        <b>Name:</b> {pf_name}<br>
        <b>PF_ID:</b> {pf_id}<br>
        <b>Type:</b> {pf_type}<br>
        <b>Aliases:</b> {pf_aliases}<br>
        <b>Lat:</b> {pf_lat}<br>
        <b>Lon:</b> {pf_lon}
        """
        popup_pf = folium.Popup(popup_html_pf, max_width=350)
        tooltip_pf = f"✅ PF Объед.: {pf_name} (PFID: {pf_id})"
    
        folium.CircleMarker(
            location=[pf_lat, pf_lon],
            radius=5,
            color="red",
            fill=True,
            fill_color="red",
            fill_opacity=0.5,
            popup=popup_pf,
            tooltip=tooltip_pf
        ).add_to(m)
    
    # Bayut
    bayut_data = true_connected_df[true_connected_df["externalID"] == bayut_id]
    if not bayut_data.empty:
        bayut_lat = bayut_data["lat"].values[0]
        bayut_lon = bayut_data["lon"].values[0]
        bayut_name = bayut_data["name"].values[0] if "name" in bayut_data else "N/A"
        bayut_type = bayut_data["type"].values[0] if "type" in bayut_data else "N/A"
        bayut_aliases = bayut_data["aliases"].values[0] if "aliases" in bayut_data else "N/A"
    
        popup_html_bayut = f"""
        <b>Bayut Info (Объед.)</b><br>
        <b>Name:</b> {bayut_name}<br>
        <b>Bayut ID:</b> {bayut_id}<br>
        <b>Type:</b> {bayut_type}<br>
        <b>Aliases:</b> {bayut_aliases}<br>
        <b>Lat:</b> {bayut_lat}<br>
        <b>Lon:</b> {bayut_lon}
        """
        popup_bayut = folium.Popup(popup_html_bayut, max_width=350)
        tooltip_bayut = f"✅ Bayut Объед.: {bayut_name} (BayutID: {bayut_id})"
    
        folium.CircleMarker(
            location=[bayut_lat, bayut_lon],
            radius=5,
            color="orange",
            fill=True,
            fill_color="orange",
            fill_opacity=0.5,
            popup=popup_bayut,
            tooltip=tooltip_bayut
        ).add_to(m)
    
        # Линия между точками
        folium.PolyLine(
            locations=[[pf_lat, pf_lon], [bayut_lat, bayut_lon]],
            color="black",
            weight=2
        ).add_to(m)
    

    ValueError Traceback (most recent call last) Cell In[71], line 73 61 folium.CircleMarker( 62 location=[pf_lat, pf_lon], 63 radius=5, (...) 69 tooltip=tooltip_pf 70 ).add_to(m) 72 # Bayut ---> 73 bayut_data = true_connected_df[true_connected_df["externalID"] == bayut_id] 74 if not bayut_data.empty: 75 bayut_lat = bayut_data["lat"].values[0]

    File ~\projects\connection-bayut-pf.venv\Lib\site-packages\pandas\core\ops\common.py:76, in _unpack_zerodim_and_defer..new_method(self, other) 72 return NotImplemented 74 other = item_from_zerodim(other) ---> 76 return method(self, other)

    File ~\projects\connection-bayut-pf.venv\Lib\site-packages\pandas\core\arraylike.py:40, in OpsMixin.eq(self, other) 38 @unpack_zerodim_and_defer("eq") 39 def eq(self, other): ---> 40 return self._cmp_method(other, operator.eq)

    File ~\projects\connection-bayut-pf.venv\Lib\site-packages\pandas\core\series.py:6119, in Series._cmp_method(self, other, op) 6116 lvalues = self._values 6117 rvalues = extract_array(other, extract_numpy=True, extract_range=True) -> 6119 res_values = ops.comparison_op(lvalues, rvalues, op) 6121 return self._construct_result(res_values, name=res_name)

    File ~\projects\connection-bayut-pf.venv\Lib\site-packages\pandas\core\ops\array_ops.py:321, in comparison_op(left, right, op) 316 if isinstance(rvalues, (np.ndarray, ABCExtensionArray)): 317 # TODO: make this treatment consistent across ops and classes. 318 # We are not catching all listlikes here (e.g. frozenset, tuple) 319 # The ambiguous case is object-dtype. See GH#27803 320 if len(lvalues) != len(rvalues): --> 321 raise ValueError( 322 "Lengths must match to compare", lvalues.shape, rvalues.shape 323 ) 325 if should_extension_dispatch(lvalues, rvalues) or ( 326 (isinstance(rvalues, (Timedelta, BaseOffset, Timestamp)) or right is NaT) 327 and lvalues.dtype != object 328 ): 329 # Call the method on lvalues 330 res_values = op(lvalues, rvalues)

    ValueError: ('Lengths must match to compare', (10142,), (0,))

  30. Assistant

    Ошибка ValueError: ('Lengths must match to compare', (10142,), (0,)) возникает, когда вы пытаетесь сравнить два объекта pandas Series, имеющих разные длины. В вашем случае, ошибка возникает при сравнении true_connected_df["externalID"] == bayut_id. Это говорит о том, что при определенных значениях bayut_id, DataFrame true_connected_df[true_connected_df["externalID"] == bayut_id] возвращает пустой DataFrame, что означает, что в столбце externalID нет значений, равных bayut_id. Следовательно, попытка сравнения true_connected_df["externalID"] (длиной 10142, как указано в ошибке) с bayut_id для пустой выборки вызывает ошибку.

    Чтобы это исправить, нужно проверять, не является ли true_connected_df пустым, перед тем, как обращаться к его столбцам:

    for pf_id, bayut_id in pf_bayut_mapping_single.items():
        # PF
        pf_data = pf_buildings_df[pf_buildings_df["id"] == pf_id]
        if not pf_data.empty:
            pf_lat = pf_data["lat"].values[0]
            pf_lon = pf_data["lon"].values[0]
            pf_name = pf_data["name"].values[0] if "name" in pf_data else "N/A"
            pf_type = pf_data["location_type"].values[0] if "location_type" in pf_data else "N/A"
            pf_aliases = pf_data["aliases"].values[0] if "aliases" in pf_data else "N/A"
    
            popup_html_pf = f"""
            <b>PF Info (Объед.)</b><br>
            <b>Name:</b> {pf_name}<br>
            <b>PF_ID:</b> {pf_id}<br>
            <b>Type:</b> {pf_type}<br>
            <b>Aliases:</b> {pf_aliases}<br>
            <b>Lat:</b> {pf_lat}<br>
            <b>Lon:</b> {pf_lon}
            """
            popup_pf = folium.Popup(popup_html_pf, max_width=350)
            tooltip_pf = f"✅ PF Объед.: {pf_name} (PFID: {pf_id})"
    
            folium.CircleMarker(
                location=[pf_lat, pf_lon],
                radius=5,
                color="red",
                fill=True,
                fill_color="red",
                fill_opacity=0.5,
                popup=popup_pf,
                tooltip=tooltip_pf
            ).add_to(m)
    
        # Bayut
        bayut_data = true_connected_df[true_connected_df["externalID"] == bayut_id]
        if not bayut_data.empty:  # Check if bayut_data is empty *before* accessing its columns
            if not bayut_data.empty:
                bayut_lat = bayut_data["lat"].values[0]
                bayut_lon = bayut_data["lon"].values[0]
                bayut_name = bayut_data["name"].values[0] if "name" in bayut_data else "N/A"
                bayut_type = bayut_data["type"].values[0] if "type" in bayut_data else "N/A"
                bayut_aliases = bayut_data["aliases"].values[0] if "aliases" in bayut_data else "N/A"
    
                popup_html_bayut = f"""
                <b>Bayut Info (Объед.)</b><br>
                <b>Name:</b> {bayut_name}<br>
                <b>Bayut ID:</b> {bayut_id}<br>
                <b>Type:</b> {bayut_type}<br>
                <b>Aliases:</b> {bayut_aliases}<br>
                <b>Lat:</b> {bayut_lat}<br>
                <b>Lon:</b> {bayut_lon}
                """
                popup_bayut = folium.Popup(popup_html_bayut, max_width=350)
                tooltip_bayut = f"✅ Bayut Объед.: {bayut_name} (BayutID: {bayut_id})"
    
                folium.CircleMarker(
                    location=[bayut_lat, bayut_lon],
                    radius=5,
                    color="orange",
                    fill=True,
                    fill_color="orange",
                    fill_opacity=0.5,
                    popup=popup_bayut,
                    tooltip=tooltip_bayut
                ).add_to(m)
    
                # Линия между точками
                folium.PolyLine(
                    locations=[[pf_lat, pf_lon], [bayut_lat, bayut_lon]],
                    color="black",
                    weight=2
                ).add_to(m)
    

    Объяснение изменений:

    Добавлена проверка if not bayut_data.empty: перед тем, как обращаться к столбцам bayut_data. Это гарантирует, что код внутри блока if будет выполнен только в том случае, если bayut_data содержит данные. Таким образом, ошибка ValueError больше не должна возникать.

    Важно:

    • Убедитесь, что у вас есть столбцы lat, lon, name, type, и aliases в вашем DataFrame true_connected_df. Если каких-то столбцов нет, предусмотрите соответствующие проверки (if "name" in bayut_data: и т.п.). Это сделано в вашем коде, но стоит убедиться.
    • true_connected_df содержит корректные данные. Проверьте, что externalID содержит ожидаемые значения.

    С этой проверкой код должен работать корректно, даже если bayut_id не найден в true_connected_df.

  31. User

    def save_mapping_with_unique_name( mapping: map[int: list[int]], filename: str = "backup_mapping", backup_dir: str = "../backup", ) -> str: os.makedirs(backup_dir, exist_ok=True)

    if filename.endswith('.json'):
        filename = filename[:-5]
    
    base_path = os.path.join(backup_dir, filename)
    file_path = base_path + ".json"
    counter = 1
    while os.path.exists(file_path):
        file_path = f"{base_path}_{counter}.json"
        counter += 1
    
    mapping_to_save = {int(k): [int(x) for x in v] for k, v in mapping.items()}
    
    with open(file_path, "w", encoding="utf-8") as file:
        json.dump(mapping_to_save, file, ensure_ascii=False, indent=2)
    
    print(f"Словарь сохранён в {file_path}")
    return file_path
    

    save_mapping_with_unique_name(pf_bayut_mapping)


    TypeError Traceback (most recent call last) Cell In[75], line 2 1 def save_mapping_with_unique_name( ----> 2 mapping: map[int: list[int]], 3 filename: str = "backup_mapping", 4 backup_dir: str = "../backup", 5 ) -> str: 6 os.makedirs(backup_dir, exist_ok=True) 8 if filename.endswith('.json'):

    TypeError: type 'map' is not subscriptable

  32. Assistant

    Ошибка TypeError: type 'map' is not subscriptable означает, что вы пытаетесь использовать оператор [] (или [:]) для доступа к элементу типа map. В Python тип map - это встроенная функция, которая используется для применения функции к каждому элементу итерируемого объекта. Она не является контейнером (как список или словарь), к которому можно обращаться по индексу.

    В вашем коде ошибка возникает в объявлении типа аргумента mapping: map[int: list[int]]. Тип map нельзя использовать таким образом для аннотации типов словарей. Вместо этого следует использовать dict.

    Вот исправленный код:

    import os
    import json
    
    def save_mapping_with_unique_name(
            mapping: dict[int, list[int]],  # Исправлено: используем dict вместо map
            filename: str = "backup_mapping",
            backup_dir: str = "../backup",
    ) -> str:
        os.makedirs(backup_dir, exist_ok=True)
    
        if filename.endswith('.json'):
            filename = filename[:-5]
    
        base_path = os.path.join(backup_dir, filename)
        file_path = base_path + ".json"
        counter = 1
        while os.path.exists(file_path):
            file_path = f"{base_path}_{counter}.json"
            counter += 1
    
        mapping_to_save = {int(k): [int(x) for x in v] for k, v in mapping.items()}
    
        with open(file_path, "w", encoding="utf-8") as file:
            json.dump(mapping_to_save, file, ensure_ascii=False, indent=2)
    
        print(f"Словарь сохранён в {file_path}")
        return file_path
    
    
    # Пример использования (предполагается, что pf_bayut_mapping уже определен)
    # pf_bayut_mapping = {1: [2, 3], 4: [5]}  # Пример данных
    # save_mapping_with_unique_name(pf_bayut_mapping)
    

    Изменения:

    • mapping: dict[int, list[int]]: Заменил map[int: list[int]] на dict[int, list[int]]. Это правильный способ аннотировать тип словаря, где ключи - целые числа, а значения - списки целых чисел.

    Причина ошибки:

    map в Python - это функция: map(function, iterable, ...)

    dict в Python - это тип данных "словарь": dict = {key: value}.

    Когда вы пытаетесь использовать map[...] для указания типа переменной, Python думает, что вы пытаетесь использовать оператор доступа по индексу [] к самой функции map, что недопустимо.

    После исправления аннотации типов код должен работать правильно. Убедитесь, что переменная pf_bayut_mapping определена до вызова save_mapping_with_unique_name. Я закомментировал пример использования, потому что не знаю, как у вас определен pf_bayut_mapping. Раскомментируйте его и замените пример данных на свои, когда будете тестировать код.

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