download Namespace Reference

Functions
	DownloadChEMBLCellLines ()
	DownloadChEMBLCompounds ()
	DownloadChEMBLTargets ()
	DownloadPubChemCompoundsToxicity ()
	DownloadTargetChEMBLActivities (pd.DataFrame targets_data)
	GetCellLineChEMBLActivitiesFromCSV (pd.DataFrame cell_lines_data)

Detailed Description

ChEMBL_download_activities/download.py

Этот модуль содержит функции для скачивания и обработки данных об активностях,
связанных с мишенями и клеточными линиями из базы данных ChEMBL,
а также для сохранения молекулярных файлов (molfiles) в формате SDF.

ChEMBL_download_cell_lines/download.py

Этот модуль отвечает за скачивание данных о клеточных линиях из базы данных
ChEMBL и сохранение их в файлы.

ChEMBL_download_compounds/download.py

Этот модуль отвечает за скачивание данных о соединениях из базы данных
ChEMBL и их объединение.

ChEMBL_download_targets/download.py

Этот модуль отвечает за скачивание информации о мишенях из базы данных
ChEMBL, используя конфигурацию из `config.json`.

PubChem_download_toxicity/download.py

Этот модуль отвечает за скачивание данных о токсичности соединений из базы
данных PubChem и их обработку.

Function Documentation

DownloadChEMBLCellLines()

download.DownloadChEMBLCellLines

(

)

Скачивает информацию о клеточных линиях из базы данных ChEMBL на основе
конфигурации (`config.json`).

def DownloadChEMBLCellLines():
  """
  Скачивает информацию о клеточных линиях из базы данных ChEMBL на основе
  конфигурации (`config.json`).
  """
 
  # конфигурация для скачивания клеточных линий.
  cell_lines_config: Config = config["ChEMBL_download_cell_lines"]
  # конфигурация для скачивания активностей.
  activities_config: Config = config["ChEMBL_download_activities"]
 
  v_logger.UpdateFormat(cell_lines_config["logger_label"],
                        cell_lines_config["logger_color"])
 
  v_logger.info(f"{"• " * 10} ChEMBL downloading for DrugDesign.")
 
  # создаем директорию для сохранения результатов, если она не существует.
  os.makedirs(cell_lines_config["results_folder_name"], exist_ok=True)
 
  # если нужно скачивать активности, создаем и для них директорию.
  if cell_lines_config["download_activities"]:
    os.makedirs(activities_config["results_folder_name"], exist_ok=True)
 
  # если установлен флаг тестирования, ограничиваем список id.
  if config["testing_flag"]:
    cell_lines_config["id_list"] = ["CHEMBL4295386", "CHEMBL3307781"]
 
  # если не нужно пропускать скачанные или файл не существует.
  if not config["skip_downloaded"] or not IsFileInFolder(
          f"{cell_lines_config["results_file_name"]}.csv",
          f"{cell_lines_config["results_folder_name"]}"):
 
    # если нужно скачивать все, очищаем список id (скачаются все).
    if cell_lines_config["download_all"]:
      cell_lines_config["id_list"] = []
 
    DownloadCellLinesFromIdList()
 
  # если файл уже скачан, пропускаем.
  else:
    v_logger.info(
        f"{cell_lines_config["results_file_name"]} is already "
        f"downloaded, skip.",
        LogMode.VERBOSELY)
 
  v_logger.success(f"{"• " * 10} ChEMBL downloading for DrugDesign!")
  v_logger.info()

DownloadChEMBLCompounds()

download.DownloadChEMBLCompounds

(

)

Скачивает информацию о соединениях из базы данных ChEMBL на основе
конфигурации (`config.json`).

def DownloadChEMBLCompounds():
  """
  Скачивает информацию о соединениях из базы данных ChEMBL на основе
  конфигурации (`config.json`).
  """
 
  # получаем конфигурацию для скачивания соединений.
  compounds_config: Config = config["ChEMBL_download_compounds"]
 
  # проверяем, что если нужно удалять файлы после объединения, то и
  # объединение должно быть включено.
  if compounds_config["delete_after_combining"] and \
          not compounds_config["need_combining"]:
    raise ValueError(
        "DownloadChEMBLCompounds: delete_after_combining=True but "
        "need_combine=False")
 
  v_logger.UpdateFormat(compounds_config["logger_label"],
                        compounds_config["logger_color"])
 
  v_logger.info(f"{"• " * 10} ChEMBL downloading for DrugDesign.")
 
  # создаем директорию для результатов, если она не существует.
  os.makedirs(compounds_config["results_folder_name"], exist_ok=True)
 
  # если установлен флаг тестирования, ограничиваем диапазоны молекулярных масс.
  if config["testing_flag"]:
    compounds_config["mw_ranges"] = [[0, 50], [50, 75]]
 
  # итерируемся по диапазонам молекулярных масс.
  for mw_range in compounds_config["mw_ranges"]:
    less_limit = mw_range[0]
    greater_limit = mw_range[1]
 
    # если не нужно пропускать скачанные или файл не существует.
    if not config["skip_downloaded"] or not IsFileInFolder(
            f"range_{less_limit}_{greater_limit}_mw_mols.csv",
            f"{compounds_config["results_folder_name"]}"):
      # скачиваем соединения для текущего диапазона.
      DownloadCompoundsByMWRange(
          less_limit,
          greater_limit,
          results_folder_name=compounds_config["results_folder_name"]
      )
 
    # если файл уже скачан, пропускаем.
    else:
      v_logger.info(
          f"Molecules with mw in range [{less_limit}, "
          f"{greater_limit}) is already downloaded, skip.",
          LogMode.VERBOSELY)
 
    v_logger.info("-", LogMode.VERBOSELY)
 
  # если нужно объединять файлы.
  if compounds_config["need_combining"]:
    # объединяем CSV файлы в папке.
    CombineCSVInFolder(compounds_config["results_folder_name"],
                       compounds_config["combined_file_name"])
 
  # если нужно удалять файлы после объединения и объединение включено.
  if compounds_config["delete_after_combining"] and \
          compounds_config["need_combining"]:
    v_logger.info(
        f"Deleting files after combining in "
        f"'{compounds_config["results_folder_name"]}'...")
 
    # удаляем файлы, кроме объединенного.
    DeleteFilesInFolder(compounds_config["results_folder_name"], [
        f"{compounds_config["combined_file_name"]}.csv"])
 
    v_logger.success(
        f"Deleting files after combining in "
        f"'{compounds_config["results_folder_name"]}'!")
 
  v_logger.success(f"{"• " * 10} ChEMBL downloading for DrugDesign!")
  v_logger.info()

DownloadChEMBLTargets()

download.DownloadChEMBLTargets

(

)

Скачиваем информацию о мишенях из базы данных ChEMBL на основе
конфигурации (`config.json`).

def DownloadChEMBLTargets():
  """
  Скачиваем информацию о мишенях из базы данных ChEMBL на основе
  конфигурации (`config.json`).
  """
 
  # получаем конфигурацию для скачивания мишеней.
  targets_config: Config = config["ChEMBL_download_targets"]
  # получаем конфигурацию для скачивания активностей.
  activities_config: Config = config["ChEMBL_download_activities"]
 
  v_logger.UpdateFormat(targets_config["logger_label"],
                        targets_config["logger_color"])
 
  v_logger.info(f"{"• " * 10} ChEMBL downloading for DrugDesign.")
 
  # создаем директорию для результатов скачивания, если она не существует.
  os.makedirs(targets_config["results_folder_name"], exist_ok=True)
 
  # если нужно скачивать активности, создаем директорию для активностей.
  if targets_config["download_activities"]:
    os.makedirs(activities_config["results_folder_name"], exist_ok=True)
 
  # если установлен флаг тестирования, используем ограниченный список id.
  if config["testing_flag"]:
    targets_config["id_list"] = ["CHEMBL1951", "CHEMBL2034"]
 
  # если файлы не скачаны или их нет в папке.
  if not config["skip_downloaded"] or not IsFileInFolder(
          targets_config["results_file_name"],
          targets_config["results_folder_name"]):
    # если скачиваем все мишени, очищаем список id.
    if targets_config["download_all"]:
      targets_config["id_list"] = []
 
    # скачиваем данные о мишенях.
    DownloadTargetsFromIdList()
 
  # если файлы уже скачаны, пропускаем.
  else:
    v_logger.info(
        f"{targets_config["results_file_name"]} is already "
        f"downloaded, skip",
        LogMode.VERBOSELY)
 
  v_logger.info(f"{"• " * 10} ChEMBL downloading for DrugDesign!")
  v_logger.info()

DownloadPubChemCompoundsToxicity()

download.DownloadPubChemCompoundsToxicity

(

)

Скачиваем информацию о токсичности соединений из базы данных PubChem на
основе конфигурации (`config.json`).

def DownloadPubChemCompoundsToxicity():
  """
  Скачиваем информацию о токсичности соединений из базы данных PubChem на
  основе конфигурации (`config.json`).
  """
 
  # конфигурация для скачивания данных о токсичности.
  toxicity_config: Config = config["PubChem_download_toxicity"]
 
  # путь к папке для результатов в единицах "kg".
  results_folder_kg: str = f"{toxicity_config["results_folder_name"]}/kg"
  # путь к папке для результатов в единицах "m3".
  results_folder_m3: str = f"{toxicity_config["results_folder_name"]}/m3"
 
  # если установлен флаг тестирования, ограничиваем диапазон страниц.
  if config["testing_flag"]:
    toxicity_config["start_page"] = 1
    toxicity_config["end_page"] = 3
 
  v_logger.UpdateFormat(toxicity_config["logger_label"],
                        toxicity_config["logger_color"])
 
  v_logger.info(f"{"• " * 10} PubChem downloading for DrugDesign.")
 
  # если файлы не скачаны или их нет в папке.
  if not config["skip_downloaded"] or\
      not IsFileInFolder(
          f"{toxicity_config["combined_file_name"]}_m3.csv",
          toxicity_config["results_folder_name"]) or\
      not IsFileInFolder(
          f"{toxicity_config["combined_file_name"]}_kg.csv",
          toxicity_config["results_folder_name"]):
    # итерируемся по страницам (включая последнюю).
    for page_num in range(toxicity_config["start_page"],
                          toxicity_config["end_page"] + 1):
      v_logger.info(f"Downloading page_{page_num}...")
 
      # формируем имя папки для текущей страницы.
      page_folder_name = f"{toxicity_config["results_folder_name"]}/"\
          "{unit_type}/page_{page_num}"
 
      # если существуют папки для следующих страниц, значит, эти полностью загружены.
      if config["skip_downloaded"] and\
              (os.path.exists(page_folder_name.format(unit_type="kg",
                                                      page_num=page_num + 1)) or
               os.path.exists(page_folder_name.format(unit_type="m3",
                                                      page_num=page_num + 1))):
        v_logger.info(f"Folder for page_{page_num} is already exists, skip.")
        continue
 
      # создаем директории для единиц измерения "kg" и "m3".
      os.makedirs(page_folder_name.format(unit_type="kg",
                                          page_num=page_num), exist_ok=True)
      os.makedirs(page_folder_name.format(unit_type="m3",
                                          page_num=page_num), exist_ok=True)
 
      # формируем ссылку для скачивания данных о соединениях.
      compound_link: str =\
          "https://pubchem.ncbi.nlm.nih.gov/rest/pug_view/annotations/"\
          "heading/JSON"\
          "?heading=Acute+Effects"\
          f"&page={page_num}"
 
      # получаем данные с веб-страницы.
      data = GetResponse(compound_link,
                         False,
                         toxicity_config["sleep_time"]).json()["Annotations"]
 
      # получаем количество аннотаций на странице.
      annotation_len = len(data["Annotation"])
      v_logger.info(f"Amount: {annotation_len}", LogMode.VERBOSELY)
 
      # определяем границы для объединения файлов по частям.
      quarters: dict[int, int] = {annotation_len - 1: 100,
                                  int(0.75 * annotation_len): 75,
                                  int(0.50 * annotation_len): 50,
                                  int(0.25 * annotation_len): 25}
 
      # получаем общее количество страниц.
      total_pages = int(data["TotalPages"])
 
      # проверяем, что номер текущей страницы не превышает общее количество.
      if page_num > total_pages:
        v_logger.LogException(IndexError(
            f"Invalid page index: '{page_num}'! Should be: 1 < 'page' < "
            f"{total_pages}"))
        continue
 
      # итерируемся по данным о соединениях.
      for i, compound_data in enumerate(data["Annotation"]):
        # фиксируем время начала обработки.
        start_time = time.time()
 
        # скачиваем данные о токсичности соединения.
        DownloadCompoundToxicity(compound_data,
                                 f"{toxicity_config["results_folder_name"]}/"
                                 "{unit_type}/"f"page_{page_num}")
 
        # фиксируем время окончания обработки.
        end_time = time.time()
 
        # если включен флаг тестирования, выводим время обработки.
        if config["testing_flag"]:
          v_logger.info(
              f"Prev compound: {i}, time: {(end_time - start_time):.3f}"
              f" sec.",
              LogMode.VERBOSELY)
 
        # если достигнута граница для объединения файлов.
        if i in quarters.keys() and toxicity_config["need_combining"]:
          # получаем номер текущей границы.
          quarter = quarters[i]
 
          v_logger.info(f"Quarter: {quarter}%, combining files in "
                        f"page_{page_num} folder...")
 
          # объединяем CSV-файлы для единиц измерения "kg".
          CombineCSVInFolder(page_folder_name.format(unit_type="kg",
                                                     page_num=page_num),
                             f"{toxicity_config["results_file_name"]}_"
                             f"{quarters[i]}_page_{page_num}")
 
          # объединяем CSV-файлы для единиц измерения "m3".
          CombineCSVInFolder(page_folder_name.format(unit_type="m3",
                                                     page_num=page_num),
                             f"{toxicity_config["results_file_name"]}_"
                             f"{quarters[i]}_page_{page_num}")
 
          v_logger.success(f"Quarter: {quarter}%, combining files in "
                           f"page_{page_num} folder!")
 
          # перемещаем объединенные файлы.
          v_logger.info(
              f"Moving {toxicity_config["results_file_name"]}_"
              f"{quarters[i]}_page_{page_num}.csv to "
              f"{toxicity_config["results_folder_name"]}...",
              LogMode.VERBOSELY)
 
          # формируем имя файла для перемещения.
          quarter_file_name = f"{toxicity_config["results_file_name"]}_"\
              f"{quarters[i]}_page_{page_num}.csv"
 
          # перемещаем файл для единиц измерения "kg".
          MoveFileToFolder(quarter_file_name,
                           page_folder_name.format(unit_type="kg",
                                                   page_num=page_num),
                           results_folder_kg)
 
          # перемещаем файл для единиц измерения "m3".
          MoveFileToFolder(quarter_file_name,
                           page_folder_name.format(unit_type="m3",
                                                   page_num=page_num),
                           results_folder_m3)
 
          v_logger.success(
              f"Moving {quarter_file_name} to "
              f"{toxicity_config["results_folder_name"]}!",
              LogMode.VERBOSELY)
 
          # удаляем предыдущий объединенный файл.
          prev_quarter = quarter - 25
 
          # если предыдущая часть не равна нулю.
          if prev_quarter != 0:
            # формируем имя предыдущего файла.
            old_quarter_file_name: str =\
                f"{toxicity_config["results_file_name"]}_"\
                f"{prev_quarter}_page_{page_num}"
 
            v_logger.info("Deleting old quarter file...",
                          LogMode.VERBOSELY)
 
            # удаляем старый файл для единиц измерения "kg".
            if os.path.exists(os.path.join(results_folder_kg,
                                           f"{old_quarter_file_name}.csv")):
              os.remove(os.path.join(
                  results_folder_kg,
                  f"{old_quarter_file_name}.csv"))
 
            # удаляем старый файл для единиц измерения "m3".
            if os.path.exists(os.path.join(results_folder_m3,
                                           f"{old_quarter_file_name}.csv")):
              os.remove(os.path.join(
                  results_folder_m3,
                  f"{old_quarter_file_name}.csv"))
 
            v_logger.success("Deleting old quarter file!",
                             LogMode.VERBOSELY)
 
    if toxicity_config["need_combining"]:
      # объединяем все CSV-файлы в папке для единиц измерения "kg".
      CombineCSVInFolder(results_folder_kg,
                         f"{toxicity_config["combined_file_name"]}_kg")
 
      # перемещаем объединенный файл в основную папку.
      MoveFileToFolder(f"{toxicity_config["combined_file_name"]}_kg.csv",
                       results_folder_kg,
                       toxicity_config["results_folder_name"])
 
      # объединяем все CSV-файлы в папке для единиц измерения "m3".
      CombineCSVInFolder(results_folder_m3,
                         f"{toxicity_config["combined_file_name"]}_m3")
 
      # перемещаем объединенный файл в основную папку.
      MoveFileToFolder(f"{toxicity_config["combined_file_name"]}_m3.csv",
                       results_folder_m3,
                       toxicity_config["results_folder_name"])
 
    # если включено удаление файлов после объединения и объединение включено.
    if toxicity_config["delete_after_combining"] and \
            toxicity_config["need_combining"]:
      v_logger.info(
          f"Deleting files after combining in "
          f"'{toxicity_config["results_folder_name"]}'...",
          LogMode.VERBOSELY)
 
      # определяем файлы, которые не нужно удалять.
      except_items: list[str] = [
          f"{toxicity_config["combined_file_name"]}_kg.csv",
          f"{toxicity_config["combined_file_name"]}_m3.csv"]
      # получаем имя папки с molfile.
      molfiles_folder_name: str = toxicity_config["molfiles_folder_name"]
 
      # проверяем, что molfiles_folder_name находится внутри results_folder_name.
      if toxicity_config["results_folder_name"] in molfiles_folder_name:
        except_items.append(molfiles_folder_name.replace(
            toxicity_config["results_folder_name"], "").split("/")[1])
 
      # удаляем все файлы, кроме указанных в списке except_items.
      DeleteFilesInFolder(toxicity_config["results_folder_name"],
                          except_items,
                          delete_folders=True)
 
      v_logger.success(
          f"Deleting files after combining in "
          f"'{toxicity_config["results_folder_name"]}'!",
          LogMode.VERBOSELY)
 
  # если файлы уже скачаны, пропускаем.
  else:
    v_logger.info(
        f"{toxicity_config["results_file_name"]} is already "
        f"downloaded, skip.",
        LogMode.VERBOSELY)
 
  if toxicity_config["filtering"]["need_filtering_by_characteristics"]:
    v_logger.info("·", LogMode.VERBOSELY)
 
    FilterDownloadedToxicityByCharacteristics("m3",
                                              "organism",
                                              "time_period",
                                              "testtype")
 
    v_logger.info()
 
    FilterDownloadedToxicityByCharacteristics("kg",
                                              "organism",
                                              "route",
                                              "testtype")
 
  v_logger.success(f"{"• " * 10} PubChem downloading for DrugDesign!")
  v_logger.info()

DownloadTargetChEMBLActivities()

download.DownloadTargetChEMBLActivities

(

pd.DataFrame

targets_data

)

Скачивает информацию об активностях (IC50 и Ki), связанных с заданными мишенями,
из базы данных ChEMBL и сохраняет их в CSV-файлы.

Также, при необходимости, скачивает соответствующие molfiles в формате SDF.

Args:
    targets_data (pd.DataFrame): DataFrame, содержащий информацию о мишенях,
                                 включая 'target_chembl_id'.

def DownloadTargetChEMBLActivities(targets_data: pd.DataFrame):
  """
  Скачивает информацию об активностях (IC50 и Ki), связанных с заданными мишенями,
  из базы данных ChEMBL и сохраняет их в CSV-файлы.
 
  Также, при необходимости, скачивает соответствующие molfiles в формате SDF.
 
  Args:
      targets_data (pd.DataFrame): DataFrame, содержащий информацию о мишенях,
                                   включая 'target_chembl_id'.
  """
 
  # конфигурация для скачивания активностей.
  activities_config: Config = config["ChEMBL_download_activities"]
  # конфигурация для скачивания соединений.
  compounds_config: Config = config["ChEMBL_download_compounds"]
 
  v_logger.UpdateFormat(activities_config["logger_label"],
                        activities_config["logger_color"])
 
  v_logger.info("Start download activities connected with targets...")
  v_logger.info("-", LogMode.VERBOSELY)
 
  # итерируемся по идентификаторам мишеней.
  for target_id in targets_data['target_chembl_id']:
    file_name_ic50: str = f"{target_id}_IC50_activities"
    file_name_ki: str = f"{target_id}_Ki_activities"
 
    # нужно ли пропускать скачивание, если файлы уже существуют.
    if config["skip_downloaded"] \
       and IsFileInFolder(f"{file_name_ic50}.csv",
                          activities_config["results_folder_name"]) \
       and IsFileInFolder(f"{file_name_ki}.csv",
                          activities_config["results_folder_name"]):
 
      v_logger.info("Activities connected with target "
                    f"{target_id} is already downloaded, skip.",
                    LogMode.VERBOSELY)
      v_logger.info("-", LogMode.VERBOSELY)
 
      continue  # переходим к следующей мишени.
 
    v_logger.info(f"Downloading activities connected with {target_id}...",
                  LogMode.VERBOSELY)
 
    # активности IC50 для мишени.
    activities_ic50: QuerySet = QuerySetActivitiesByIC50(target_id)
    # активности Ki для мишени.
    activities_ki: QuerySet = QuerySetActivitiesByKi(target_id)
 
    v_logger.info("Amount: IC50: "
                  f"{len(activities_ic50)};"  # type: ignore
                  " Ki: "
                  f"{len(activities_ki)}.", LogMode.VERBOSELY)  # type: ignore
    v_logger.success(f"Downloading activities connected with {target_id}!",
                     LogMode.VERBOSELY)
    v_logger.info("Collecting activities to pandas.DataFrame...",
                  LogMode.VERBOSELY)
 
    # очищаем DataFrame с активностями IC50.
    data_frame_ic50 = CleanedTargetActivitiesDF(
        pd.DataFrame(activities_ic50),  # type: ignore
        target_id=target_id,
        activities_type="IC50")
 
    # очищаем DataFrame с активностями Ki.
    data_frame_ki = CleanedTargetActivitiesDF(
        pd.DataFrame(activities_ki),  # type: ignore
        target_id=target_id,
        activities_type="Ki")
 
    v_logger.success("Collecting activities to pandas.DataFrame!",
                     LogMode.VERBOSELY)
    v_logger.info(
        "Recording new values 'IC50', 'Ki' in targets DataFrame...",
        LogMode.VERBOSELY)
 
    # записываем количество активностей IC50 и Ki в DataFrame с данными о мишенях.
    targets_data.loc[targets_data["target_chembl_id"] == target_id, "IC50_new"] =\
        len(data_frame_ic50)
 
    targets_data.loc[targets_data["target_chembl_id"] == target_id, "Ki_new"] =\
        len(data_frame_ki)
 
    v_logger.info("Amount: IC50: "
                  f"{len(data_frame_ic50)};"
                  " Ki: "
                  f"{len(data_frame_ki)}.", LogMode.VERBOSELY)
    v_logger.success(
        "Recording new values 'IC50', 'Ki' in targets DataFrame!",
        LogMode.VERBOSELY)
    v_logger.info(
        "Collecting activities to .csv file in "
        f"'{activities_config["results_folder_name"]}'...",
        LogMode.VERBOSELY)
 
    # полное имя файла для IC50.
    full_file_name_ic50: str = f"{activities_config["results_folder_name"]}/"\
        f"{file_name_ic50}.csv"
    # полное имя файла для Ki.
    full_file_name_ki: str = f"{activities_config["results_folder_name"]}/"\
        f"{file_name_ki}.csv"
 
    # сохраняем DataFrame с активностями IC50 в CSV.
    data_frame_ic50.to_csv(full_file_name_ic50, sep=";", index=False)
    # сохраняем DataFrame с активностями Ki в CSV.
    data_frame_ki.to_csv(full_file_name_ki, sep=";", index=False)
 
    v_logger.success(
        "Collecting activities to .csv file in "
        f"'{activities_config["results_folder_name"]}'!",
        LogMode.VERBOSELY)
 
    # включена опция скачивания molfiles.
    if activities_config["download_compounds_sdf"]:
      # обновляем формат логгера.
      v_logger.UpdateFormat(compounds_config["logger_label"],
                            compounds_config["logger_color"])
 
      v_logger.info(
          f"Start download molfiles connected with {target_id} to .sdf...",
          LogMode.VERBOSELY)
 
      # создаем директорию для molfiles, если она не существует.
      os.makedirs(compounds_config["molfiles_folder_name"], exist_ok=True)
 
      v_logger.info("Saving connected with IC50 molfiles...",
                    LogMode.VERBOSELY)
 
      # сохраняем molfiles, связанные с активностями IC50 в SDF.
      SaveChEMBLMolfilesToSDFByIdList(
          data_frame_ic50['molecule_chembl_id'].tolist(),
          f"{compounds_config["molfiles_folder_name"]}/{file_name_ic50}_molfiles",
          extra_data=data_frame_ic50)
 
      v_logger.success("Saving connected with IC50 molfiles!",
                       LogMode.VERBOSELY)
      v_logger.info("Saving connected with Ki molfiles...",
                    LogMode.VERBOSELY)
 
      # сохраняем molfiles, связанные с активностями Ki в SDF.
      SaveChEMBLMolfilesToSDFByIdList(
          data_frame_ki['molecule_chembl_id'].tolist(),
          f"{compounds_config["molfiles_folder_name"]}/{file_name_ki}_molfiles",
          extra_data=data_frame_ki)
 
      v_logger.success("Saving connected with Ki molfiles!", LogMode.VERBOSELY)
      v_logger.success(
          f"End download molfiles connected with {target_id} to .sdf!",
          LogMode.VERBOSELY)
 
      # восстанавливаем формат логгера.
      v_logger.UpdateFormat(activities_config["logger_label"],
                            activities_config["logger_color"])
 
    v_logger.info("-", LogMode.VERBOSELY)
 
  v_logger.success("End download activities connected with targets!")
 
 
@IgnoreWarnings
@ReTry(attempts_amount=1)

GetCellLineChEMBLActivitiesFromCSV()

download.GetCellLineChEMBLActivitiesFromCSV

(

pd.DataFrame

cell_lines_data

)

"Скачивает" (получает) информацию об активностях (IC50 и GI50), связанных с
заданными клеточными линиями, из CSV-файлов, расположенных в директории,
указанной в конфигурации.  Также, при необходимости, скачивает
соответствующие molfiles в формате SDF.

Важно:
    В данном случае "скачивание" подразумевает чтение данных из локальных
    CSV-файлов, а не загрузку из ChEMBL API.

Args:
    cell_lines_data (pd.DataFrame): DataFrame, содержащий информацию
                                     о клеточных линиях, включая 'cell_chembl_id'.

def GetCellLineChEMBLActivitiesFromCSV(cell_lines_data: pd.DataFrame):
  """
  "Скачивает" (получает) информацию об активностях (IC50 и GI50), связанных с
  заданными клеточными линиями, из CSV-файлов, расположенных в директории,
  указанной в конфигурации.  Также, при необходимости, скачивает
  соответствующие molfiles в формате SDF.
 
  Важно:
      В данном случае "скачивание" подразумевает чтение данных из локальных
      CSV-файлов, а не загрузку из ChEMBL API.
 
  Args:
      cell_lines_data (pd.DataFrame): DataFrame, содержащий информацию
                                       о клеточных линиях, включая 'cell_chembl_id'.
  """
 
  # конфигурация для активностей.
  activities_config: Config = config["ChEMBL_download_activities"]
  # конфигурация для клеточных линий.
  cell_lines_config: Config = config["ChEMBL_download_cell_lines"]
  # конфигурация для соединений.
  compounds_config: Config = config["ChEMBL_download_compounds"]
 
  # сохраняем текущий индекс формата логгера.
  restore_index: int = v_logger.UpdateFormat(activities_config["logger_label"],
                                             activities_config["logger_color"]) - 1
 
  v_logger.info("Start getting activities connected with cell_lines...")
  v_logger.info("-", LogMode.VERBOSELY)
 
  # итерируемся по идентификаторам клеточных линий.
  for cell_id in cell_lines_data['cell_chembl_id']:
    file_name_ic50: str = f"{cell_id}_IC50_activities"
    file_name_gi50: str = f"{cell_id}_GI50_activities"
 
    # нужно ли пропускать загрузку, если файлы уже существуют.
    if config["skip_downloaded"] \
       and IsFileInFolder(f"{file_name_ic50}.csv",
                          activities_config["results_folder_name"]) \
       and IsFileInFolder(f"{file_name_gi50}.csv",
                          activities_config["results_folder_name"]):
 
      v_logger.info("Activities connected with target "
                    f"{cell_id} is already gotten, skip", LogMode.VERBOSELY)
      v_logger.info("-", LogMode.VERBOSELY)
 
      continue  # переходим к следующей клеточной линии.
 
    v_logger.info(
        f"Getting activities connected with {cell_id}...", LogMode.VERBOSELY)
 
    # читаем данные об активностях IC50 и GI50 из CSV-файлов.
    data_frame_ic50 = pd.read_csv(
        f"{cell_lines_config["raw_csv_folder_name"]}/{file_name_ic50}.csv",
        sep=config["csv_separator"], low_memory=False)
 
    data_frame_gi50 = pd.read_csv(
        f"{cell_lines_config["raw_csv_folder_name"]}/{file_name_gi50}.csv",
        sep=config["csv_separator"], low_memory=False)
 
    v_logger.info("Amount: "
                  f"IC50: {len(data_frame_ic50)}; "
                  f"GI50: {len(data_frame_gi50)}.", LogMode.VERBOSELY)
 
    v_logger.success(f"Getting activities connected with {cell_id}!",
                     LogMode.VERBOSELY)
    v_logger.info("Cleaning activities...", LogMode.VERBOSELY)
 
    # очищаем DataFrames с активностями IC50 и GI50.
    data_frame_ic50 = CleanedCellLineActivitiesDF(data_frame_ic50,
                                                  cell_id=cell_id,
                                                  activities_type="IC50")
 
    data_frame_gi50 = CleanedCellLineActivitiesDF(data_frame_gi50,
                                                  cell_id=cell_id,
                                                  activities_type="GI50")
 
    v_logger.success(
        "Collecting activities to pandas.DataFrame!", LogMode.VERBOSELY)
    v_logger.info(
        "Recording new values 'IC50', 'GI50' in targets DataFrame...",
        LogMode.VERBOSELY)
 
    # записываем количество активностей IC50 и GI50 в DataFrame.
    cell_lines_data.loc[
        cell_lines_data["cell_chembl_id"] == cell_id, "IC50_new"] =\
        len(data_frame_ic50)
 
    cell_lines_data.loc[
        cell_lines_data["cell_chembl_id"] == cell_id, "GI50_new"] =\
        len(data_frame_gi50)
 
    v_logger.info("Amount: "
                  f"IC50: {len(data_frame_ic50)}; "
                  f"GI50: {len(data_frame_gi50)}.", LogMode.VERBOSELY)
    v_logger.success(
        "Recording new values 'IC50', 'GI50' in targets DataFrame!",
        LogMode.VERBOSELY)
    v_logger.info(
        f"Collecting activities to .csv file in '"
        f"{activities_config["results_folder_name"]}'...", LogMode.VERBOSELY)
 
    # формируем полное имя файла для IC50.
    full_file_name_ic50: str = f"{activities_config["results_folder_name"]}/"\
        f"{file_name_ic50}.csv"
    # формируем полное имя файла для GI50.
    full_file_name_gi50: str = f"{activities_config["results_folder_name"]}/"\
        f"{file_name_gi50}.csv"
 
    # сохраняем DataFrame с активностями IC50 в CSV.
    data_frame_ic50.to_csv(full_file_name_ic50, sep=";", index=False)
    # сохраняем DataFrame с активностями GI50 в CSV.
    data_frame_gi50.to_csv(full_file_name_gi50, sep=";", index=False)
 
    v_logger.success(
        f"Collecting activities to .csv file in "
        f"'{activities_config["results_folder_name"]}'!", LogMode.VERBOSELY)
 
    # включена опция скачивания molfiles.
    if activities_config["download_compounds_sdf"]:
      # обновляем формат логгера.
      v_logger.UpdateFormat(compounds_config["logger_label"],
                            compounds_config["logger_color"])
 
      v_logger.info(
          f"Start download molfiles connected with {cell_id} to .sdf...",
          LogMode.VERBOSELY)
 
      # создаем директорию для molfiles, если она не существует.
      os.makedirs(compounds_config["molfiles_folder_name"], exist_ok=True)
 
      v_logger.info("Saving connected with IC50 molfiles...",
                    LogMode.VERBOSELY)
 
      # сохраняем molfiles, связанные с активностями IC50 в SDF.
      SaveChEMBLMolfilesToSDFByIdList(
          data_frame_ic50['molecule_chembl_id'].tolist(),
          f"{compounds_config["molfiles_folder_name"]}/{file_name_ic50}_molfiles",
          extra_data=data_frame_ic50)
 
      v_logger.success("Saving connected with IC50 molfiles!",
                       LogMode.VERBOSELY)
      v_logger.info("Saving connected with GI50 molfiles...",
                    LogMode.VERBOSELY)
 
      # сохраняем molfiles, связанные с активностями GI50 в SDF.
      SaveChEMBLMolfilesToSDFByIdList(
          data_frame_gi50['molecule_chembl_id'].tolist(),
          f"{compounds_config["molfiles_folder_name"]}/{file_name_gi50}_molfiles",
          extra_data=data_frame_gi50)
 
      v_logger.success(
          "Saving connected with GI50 molfiles!", LogMode.VERBOSELY)
      v_logger.success(
          f"End download molfiles connected with {cell_id} to .sdf!",
          LogMode.VERBOSELY)
 
      # восстанавливаем формат логгера.
      v_logger.UpdateFormat(activities_config["logger_label"],
                            activities_config["logger_color"])
 
    v_logger.info("-", LogMode.VERBOSELY)
 
  v_logger.success("End getting activities connected with cell_lines!")
 
  # восстанавливаем исходный формат логгера.
  v_logger.RestoreFormat(restore_index)