DrugDesign Data Analysis
Module of the DrugDesign project responsible for loading and pre-processing data from ChEMBL and PubChem
•All Classes Namespaces Files Functions Variables Pages
Functions | Variables
functions Namespace Reference

Functions

pd.DataFrame AddedIC50andGI50ToCellLinesDF (pd.DataFrame data)
 
pd.DataFrame AddedIC50andKiToTargetsDF (pd.DataFrame data)
 
pd.DataFrame CleanedCellLineActivitiesDF (pd.DataFrame data, str cell_id, str activities_type)
 
pd.DataFrame CleanedTargetActivitiesDF (pd.DataFrame data, str target_id, str activities_type)
 
int CountCellLineActivitiesByFile (str file_name)
 
int CountTargetActivitiesByIC50 (str target_id)
 
int CountTargetActivitiesByKi (str target_id)
 
 DownloadCellLinesFromIdList ()
 
 DownloadCompoundsByMWRange (int less_limit, int greater_limit, str results_folder_name)
 
 DownloadCompoundToxicity (dict compound_data, str page_folder_name)
 
 DownloadTargetsFromIdList ()
 
pd.DataFrame ExpandedFromDictionariesCompoundsDF (pd.DataFrame data)
 
pd.DataFrame ExpandedFromDictionariesTargetsDF (pd.DataFrame data)
 
pd.DataFrame GetDataFrameFromUrl (str request_url, float sleep_time)
 
str GetLinkFromSid (int sid, str collection, int limit)
 
str GetMolfileFromCID (str cid, float|None sleep_time=toxicity_config["sleep_time"])
 
 GetRawCellLinesData (str file_id, str output_path, bool print_to_console)
 
requests.Response GetResponse (str request_url, bool stream, float|None sleep_time=toxicity_config["sleep_time"])
 
QuerySet QuerySetActivitiesByIC50 (str target_id)
 
QuerySet QuerySetActivitiesByKi (str target_id)
 
QuerySet QuerySetAllCellLines ()
 
QuerySet QuerySetAllTargets ()
 
QuerySet QuerySetCellLinesFromIdList (list[str] cell_line_chembl_id_list)
 
QuerySet QuerySetCompoundsByMWRange (int less_limit, int greater_limit)
 
QuerySet QuerySetTargetsFromIdList (list[str] target_chembl_id_list)
 
 SaveChEMBLMolfilesToSDFByIdList (list[str] molecule_chembl_id_list, str file_name, pd.DataFrame extra_data=pd.DataFrame())
 

Variables

Config filtering_config = toxicity_config["filtering"]
 
Config toxicity_config = config["PubChem_download_toxicity"]
 

Detailed Description

ChEMBL_download_activities/functions.py

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

ChEMBL_download_cell_lines/functions.py

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

ChEMBL_download_compounds/functions.py

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

ChEMBL_download_targets/functions.py

Этот модуль содержит функции для загрузки данных о целевых белках (targets)
из базы данных ChEMBL, расширения словарей в DataFrame, добавления
информации об активностях и сохранения результатов в CSV-файл.

PubChem_download_toxicity/functions.py

Этот модуль содержит функции для скачивания данных о токсичности соединений
из PubChem, их фильтрации, преобразования и сохранения в CSV и SDF файлы.

Function Documentation

◆ AddedIC50andGI50ToCellLinesDF()

pd.DataFrame functions.AddedIC50andGI50ToCellLinesDF ( pd.DataFrame data) 
Добавляет столбцы `IC50` и `GI50` в DataFrame с данными о клеточных линиях,
подсчитывая количество соответствующих активностей из CSV-файлов,
а также опционально скачивает новые активности.

Args:
    data (pd.DataFrame): DataFrame с данными о клеточных линиях.

Returns:
    pd.DataFrame: DataFrame с добавленными столбцами `IC50` и `GI50`,
                  содержащими количество соответствующих активностей.
76def AddedIC50andGI50ToCellLinesDF(data: pd.DataFrame) -> pd.DataFrame:
77 """
78 Добавляет столбцы `IC50` и `GI50` в DataFrame с данными о клеточных линиях,
79 подсчитывая количество соответствующих активностей из CSV-файлов,
80 а также опционально скачивает новые активности.
81
82 Args:
83 data (pd.DataFrame): DataFrame с данными о клеточных линиях.
84
85 Returns:
86 pd.DataFrame: DataFrame с добавленными столбцами `IC50` и `GI50`,
87 содержащими количество соответствующих активностей.
88 """
89
90 # получаем конфигурацию для клеточных линий.
91 cell_lines_config: Config = config["ChEMBL_download_cell_lines"]
92
93 v_logger.info(
94 "Adding 'IC50' and 'GI50' columns to pandas.DataFrame...", LogMode.VERBOSELY
95 )
96
97 # проверяем, пуста ли папка с необработанными данными.
98 if IsFolderEmpty(cell_lines_config["raw_csv_folder_name"]):
99 v_logger.info("Getting raw cell_lines from Google.Drive...", LogMode.VERBOSELY)
100
101 GetRawCellLinesData(
102 cell_lines_config["raw_csv_g_drive_id"],
103 cell_lines_config["raw_csv_folder_name"],
104 config["Utils"]["VerboseLogger"]["verbose_print"],
105 )
106
107 v_logger.success("Getting raw cell_lines from Google.Drive!", LogMode.VERBOSELY)
108
109 # добавляем столбец 'IC50', подсчитывая активности по файлам.
110 data["IC50"] = data.apply(
111 lambda value: CountCellLineActivitiesByFile(
112 f"{cell_lines_config['raw_csv_folder_name']}/"
113 f"{value['cell_chembl_id']}_IC50_activities.csv"
114 ),
115 axis=1,
116 )
117
118 # добавляем столбец 'GI50', подсчитывая активности по файлам.
119 data["GI50"] = data.apply(
120 lambda value: CountCellLineActivitiesByFile(
121 f"{cell_lines_config['raw_csv_folder_name']}/"
122 f"{value['cell_chembl_id']}_GI50_activities.csv"
123 ),
124 axis=1,
125 )
126
127 v_logger.success(
128 "Adding 'IC50' and 'GI50' columns to pandas.DataFrame!", LogMode.VERBOSELY
129 )
130
131 # проверяем, нужно ли скачивать активности.
132 if cell_lines_config["download_activities"]:
133 GetCellLineChEMBLActivitiesFromCSV(data)
134
135 try:
136 # оставляем только строки, в которых есть IC50_new и Ki_new
137 data = data[(data["IC50_new"].notna()) & (data["GI50_new"].notna())]
138
139 data = data.copy()
140
141 data["IC50_new"] = data["IC50_new"].astype(int)
142 data["GI50_new"] = data["GI50_new"].astype(int)
143
144 # это исключение может возникнуть, если колонки нет.
145 except KeyError as exception:
146 # новых activities не скачалось, т.е. значение пересчитывать не надо.
147 if not config["skip_downloaded"]:
148 raise exception
149
150 # это исключение может возникнуть, если какое-то значение оказалось невалидным.
151 except pd.errors.IntCastingNaNError:
152 v_logger.warning("Cannot convert non-finite values!")
153
154 return data
155
156
Here is the call graph for this function:
Here is the caller graph for this function:

◆ AddedIC50andKiToTargetsDF()

pd.DataFrame functions.AddedIC50andKiToTargetsDF ( pd.DataFrame data) 
Добавляет столбцы 'IC50' и 'Ki' в DataFrame с данными о целевых белках
(targets), подсчитывая количество соответствующих активностей из базы данных
ChEMBL, а также опционально скачивает новые активности.

Args:
    data (pd.DataFrame): DataFrame с данными о целевых белках.

Returns:
    pd.DataFrame: DataFrame с добавленными столбцами 'IC50' и 'Ki',
                  содержащими количество соответствующих активностей.
154def AddedIC50andKiToTargetsDF(data: pd.DataFrame) -> pd.DataFrame:
155 """
156 Добавляет столбцы 'IC50' и 'Ki' в DataFrame с данными о целевых белках
157 (targets), подсчитывая количество соответствующих активностей из базы данных
158 ChEMBL, а также опционально скачивает новые активности.
159
160 Args:
161 data (pd.DataFrame): DataFrame с данными о целевых белках.
162
163 Returns:
164 pd.DataFrame: DataFrame с добавленными столбцами 'IC50' и 'Ki',
165 содержащими количество соответствующих активностей.
166 """
167
168 # получаем конфигурацию для скачивания целей.
169 targets_config: Config = config["ChEMBL_download_targets"]
170
171 v_logger.info(
172 "Adding 'IC50' and 'Ki' columns to pandas.DataFrame...", LogMode.VERBOSELY
173 )
174
175 # добавляем столбец 'IC50', подсчитывая активности.
176 data["IC50"] = data["target_chembl_id"].apply(CountTargetActivitiesByIC50)
177 # добавляем столбец 'Ki', подсчитывая активности.
178 data["Ki"] = data["target_chembl_id"].apply(CountTargetActivitiesByKi)
179
180 v_logger.success(
181 "Adding 'IC50' and 'Ki' columns to pandas.DataFrame!", LogMode.VERBOSELY
182 )
183
184 # если нужно скачивать активности.
185 if targets_config["download_activities"]:
186 # скачиваем активности для целевых белков.
187 DownloadTargetChEMBLActivities(data)
188
189 try:
190 # оставляем только строки, в которых есть IC50_new и Ki_new
191 data = data[(data["IC50_new"].notna()) & (data["Ki_new"].notna())]
192
193 # преобразуем типы столбцов.
194 data["IC50_new"] = data["IC50_new"].astype(int)
195 data["Ki_new"] = data["Ki_new"].astype(int)
196
197 # это исключение может возникнуть, если колонки нет.
198 except KeyError as exception:
199 # новых activities не скачалось, т.е. значение пересчитывать не надо.
200 if not config["skip_downloaded"]:
201 raise exception
202
203 # это исключение может возникнуть, если какое-то значение оказалось невалидным.
204 except pd.errors.IntCastingNaNError:
205 v_logger.warning("Cannot convert non-finite values!")
206
207 return data
208
209
210@ReTry(attempts_amount=1)
Here is the caller graph for this function:

◆ CleanedCellLineActivitiesDF()

pd.DataFrame functions.CleanedCellLineActivitiesDF ( pd.DataFrame data,
str cell_id,
str activities_type ) 
Очищает DataFrame с данными об активностях
для указанной клеточной линии (cell_id) по IC50 и GI50.

Функция выполняет следующие шаги:
    1. Выбирает нужные столбцы из DataFrame.
    2. Переименовывает столбцы,
       приводя их к нижнему регистру и заменяя пробелы на "_".
    3. Фильтрует данные, оставляя только значения с отношениями, единицами,
       организмами и типами активности из файла с конфигурациями.
    4. Преобразует столбец "standard_value" в числовой тип.
    5. Удаляет значения "standard_value", превышающие 1000000000 (1e9).
    6. Удаляет столбец "assay_organism" и "standard_type".
    7. Переименовывает столбец "smiles" в "canonical_smiles".
    8. Вычисляет медиану для дублирующихся значений "standard_value"
       по "molecule_chembl_id".
    9. Переиндексирует столбцы DataFrame в логическом порядке.

Args:
    data (pd.DataFrame): DataFrame с данными об активностях клеточных линий.
    cell_id (str): Идентификатор клеточной линии.
    activities_type (str): Тип активности ("IC50" или "GI50")
                           (используется только для логирования).

Returns:
    pd.DataFrame: Очищенный DataFrame с данными об активностях клеточной линии.
246) -> pd.DataFrame:
247 """
248 Очищает DataFrame с данными об активностях
249 для указанной клеточной линии (cell_id) по IC50 и GI50.
250
251 Функция выполняет следующие шаги:
252 1. Выбирает нужные столбцы из DataFrame.
253 2. Переименовывает столбцы,
254 приводя их к нижнему регистру и заменяя пробелы на "_".
255 3. Фильтрует данные, оставляя только значения с отношениями, единицами,
256 организмами и типами активности из файла с конфигурациями.
257 4. Преобразует столбец "standard_value" в числовой тип.
258 5. Удаляет значения "standard_value", превышающие 1000000000 (1e9).
259 6. Удаляет столбец "assay_organism" и "standard_type".
260 7. Переименовывает столбец "smiles" в "canonical_smiles".
261 8. Вычисляет медиану для дублирующихся значений "standard_value"
262 по "molecule_chembl_id".
263 9. Переиндексирует столбцы DataFrame в логическом порядке.
264
265 Args:
266 data (pd.DataFrame): DataFrame с данными об активностях клеточных линий.
267 cell_id (str): Идентификатор клеточной линии.
268 activities_type (str): Тип активности ("IC50" или "GI50")
269 (используется только для логирования).
270
271 Returns:
272 pd.DataFrame: Очищенный DataFrame с данными об активностях клеточной линии.
273 """
274
275 # конфигурация для фильтрации активностей (клеточных линий).
276 filtering_config: Config = config["ChEMBL_download_activities"]["filtering"][
277 "cell_lines"
278 ]
279
280 v_logger.info(
281 f"Start cleaning {activities_type} activities DataFrame from {cell_id}...",
282 LogMode.VERBOSELY,
283 )
284 v_logger.info("Deleting useless columns...", LogMode.VERBOSELY)
285
286 data = data[
287 [
288 "Molecule ChEMBL ID",
289 "Smiles",
290 "Document ChEMBL ID",
291 "Standard Type",
292 "Standard Relation",
293 "Standard Value",
294 "Standard Units",
295 "Assay ChEMBL ID",
296 "Assay Description",
297 "Assay Type",
298 "Assay Variant Accession",
299 "Assay Variant Mutation",
300 "Action Type",
301 "Data Validity Comment",
302 "BAO Format ID",
303 "BAO Label",
304 "Assay Organism",
305 ]
306 ]
307
308 data.columns = [column_name.lower().replace(" ", "_") for column_name in data.columns]
309
310 v_logger.success("Deleting useless columns!", LogMode.VERBOSELY)
311 v_logger.info("Deleting inappropriate elements...", LogMode.VERBOSELY)
312
313 data = data[data["standard_relation"].isin(filtering_config["standard_relation"])]
314 data = data[data["standard_units"].isin(filtering_config["standard_units"])]
315 data = data[data["assay_organism"].isin(filtering_config["assay_organism"])]
316 data = data[data["standard_type"].isin(filtering_config["standard_type"])]
317
318 data["standard_value"] = data["standard_value"].astype(float)
319
320 max_value: int = 1000000000
321 data = data[data["standard_value"] <= max_value]
322
323 data = data.drop(["assay_organism", "standard_type"], axis=1)
324
325 data = data.rename(columns={"smiles": "canonical_smiles"})
326
327 v_logger.success("Deleting inappropriate elements!", LogMode.VERBOSELY)
328 v_logger.info("Calculating median for 'standard value'...", LogMode.VERBOSELY)
329
330 data = MedianDedupedDF(data, "molecule_chembl_id", "standard_value")
331
332 v_logger.success("Calculating median for 'standard value'!", LogMode.VERBOSELY)
333 v_logger.info("Reindexing columns in logical order...", LogMode.VERBOSELY)
334
335 data = data.reindex(
336 columns=[
337 "molecule_chembl_id",
338 "canonical_smiles",
339 "document_chembl_id",
340 "standard_relation",
341 "standard_value",
342 "standard_units",
343 "assay_chembl_id",
344 "assay_description",
345 "assay_type",
346 "assay_variant_accession",
347 "assay_variant_mutation",
348 "action_type",
349 "data_validity_description",
350 "bao_format",
351 "bao_label",
352 ]
353 )
354
355 v_logger.success("Reindexing columns in logical order!", LogMode.VERBOSELY)
356 v_logger.success(
357 f"End cleaning activities DataFrame from {cell_id}!", LogMode.VERBOSELY
358 )
359 v_logger.info("-", LogMode.VERBOSELY)
360
361 return data

◆ CleanedTargetActivitiesDF()

pd.DataFrame functions.CleanedTargetActivitiesDF ( pd.DataFrame data,
str target_id,
str activities_type ) 
Очищает DataFrame с данными об активностях
для указанной цели (target_id) по IC50 и Ki.

Функция выполняет следующие шаги:
    1. Удаляет неинформативные столбцы.
    2. Фильтрует данные, оставляя только значения с отношением, единицами,
       организмами, типами активности и типами анализа из файла с конфигурациями.
    3. Преобразует столбец "standard_value" в числовой тип.
    4. Удаляет значения "standard_value", превышающие 1000000000 (1e9).
    5. Заменяет значения "Not Determined" в столбце 'activity_comment' на None.
    6. Удаляет столбцы "target_organism" и "standard_type".
    7. Вычисляет медиану для дублирующихся значений "standard_value"
       по "molecule_chembl_id".
    8. Переиндексирует столбцы DataFrame в логическом порядке.

Args:
    data (pd.DataFrame): DataFrame с данными об активностях, полученными из ChEMBL.
    target_id (str): Идентификатор цели из базы ChEMBL.
    activities_type (str): Тип активности ("IC50" или "Ki")
                           (используется только для логирования).

Returns:
    pd.DataFrame: Очищенный DataFrame с данными об активностях.
116) -> pd.DataFrame:
117 """
118 Очищает DataFrame с данными об активностях
119 для указанной цели (target_id) по IC50 и Ki.
120
121 Функция выполняет следующие шаги:
122 1. Удаляет неинформативные столбцы.
123 2. Фильтрует данные, оставляя только значения с отношением, единицами,
124 организмами, типами активности и типами анализа из файла с конфигурациями.
125 3. Преобразует столбец "standard_value" в числовой тип.
126 4. Удаляет значения "standard_value", превышающие 1000000000 (1e9).
127 5. Заменяет значения "Not Determined" в столбце 'activity_comment' на None.
128 6. Удаляет столбцы "target_organism" и "standard_type".
129 7. Вычисляет медиану для дублирующихся значений "standard_value"
130 по "molecule_chembl_id".
131 8. Переиндексирует столбцы DataFrame в логическом порядке.
132
133 Args:
134 data (pd.DataFrame): DataFrame с данными об активностях, полученными из ChEMBL.
135 target_id (str): Идентификатор цели из базы ChEMBL.
136 activities_type (str): Тип активности ("IC50" или "Ki")
137 (используется только для логирования).
138
139 Returns:
140 pd.DataFrame: Очищенный DataFrame с данными об активностях.
141 """
142 # конфигурация для фильтрации активностей (мишеней).
143 filtering_config: Config = config["ChEMBL_download_activities"]["filtering"]["targets"]
144
145 v_logger.info(
146 f"Start cleaning {activities_type} activities DataFrame from {target_id}...",
147 LogMode.VERBOSELY,
148 )
149 v_logger.info("Deleting useless columns...", LogMode.VERBOSELY)
150
151 data = data.drop(
152 [
153 "activity_id",
154 "activity_properties",
155 "document_journal",
156 "document_year",
157 "molecule_pref_name",
158 "pchembl_value",
159 "potential_duplicate",
160 "qudt_units",
161 "record_id",
162 "src_id",
163 "standard_flag",
164 "standard_text_value",
165 "standard_upper_value",
166 "target_chembl_id",
167 "target_pref_name",
168 "target_tax_id",
169 "text_value",
170 "toid",
171 "type",
172 "units",
173 "uo_units",
174 "upper_value",
175 "value",
176 "ligand_efficiency",
177 "relation",
178 ],
179 axis=1,
180 )
181
182 v_logger.success("Deleting useless columns!", LogMode.VERBOSELY)
183 v_logger.info("Deleting inappropriate elements...", LogMode.VERBOSELY)
184
185 data = data[data["standard_relation"].isin(filtering_config["standard_relation"])]
186 data = data[data["standard_units"].isin(filtering_config["standard_units"])]
187 data = data[data["target_organism"].isin(filtering_config["target_organism"])]
188 data = data[data["standard_type"].isin(filtering_config["standard_type"])]
189 data = data[data["assay_type"].isin(filtering_config["assay_type"])]
190
191 data["standard_value"] = data["standard_value"].astype(float)
192 # неправдоподобные значения
193 max_value: int = 1000000000
194 data = data[data["standard_value"] <= max_value]
195
196 data["activity_comment"] = data["activity_comment"].replace("Not Determined", None)
197
198 data = data.drop(["target_organism", "standard_type"], axis=1)
199
200 v_logger.success("Deleting inappropriate elements!", LogMode.VERBOSELY)
201 v_logger.info("Calculating median for 'standard value'...", LogMode.VERBOSELY)
202
203 data = MedianDedupedDF(data, "molecule_chembl_id", "standard_value")
204
205 v_logger.success("Calculating median for 'standard value'!", LogMode.VERBOSELY)
206 v_logger.info("Reindexing columns in logical order...", LogMode.VERBOSELY)
207
208 data = data.reindex(
209 columns=[
210 "molecule_chembl_id",
211 "parent_molecule_chembl_id",
212 "canonical_smiles",
213 "document_chembl_id",
214 "standard_relation",
215 "standard_value",
216 "standard_units",
217 "assay_chembl_id",
218 "assay_description",
219 "assay_type",
220 "assay_variant_accession",
221 "assay_variant_mutation",
222 "action_type",
223 "activity_comment",
224 "data_validity_comment",
225 "data_validity_description",
226 "bao_endpoint",
227 "bao_format",
228 "bao_label",
229 ]
230 )
231
232 v_logger.success("Reindexing columns in logical order!", LogMode.VERBOSELY)
233 v_logger.success(
234 f"End cleaning activities DataFrame from {target_id}!", LogMode.VERBOSELY
235 )
236 v_logger.info("-", LogMode.VERBOSELY)
237
238 return data
239
240
241@ReTry(attempts_amount=1)

◆ CountCellLineActivitiesByFile()

int functions.CountCellLineActivitiesByFile ( str file_name) 
Подсчитывает количество строк (активностей) в CSV-файле,
содержащем данные о клеточных линиях.

Args:
    file_name (str): Имя файла CSV,
                     содержащего данные об активностях клеточных линий.

Returns:
    int: Количество строк в файле (предположительно, количество активностей).
95def CountCellLineActivitiesByFile(file_name: str) -> int:
96 """
97 Подсчитывает количество строк (активностей) в CSV-файле,
98 содержащем данные о клеточных линиях.
99
100 Args:
101 file_name (str): Имя файла CSV,
102 содержащего данные об активностях клеточных линий.
103
104 Returns:
105 int: Количество строк в файле (предположительно, количество активностей).
106 """
107
108 return sum(1 for _ in open(file_name))
109
110
111@ReTry(attempts_amount=1)

◆ CountTargetActivitiesByIC50()

int functions.CountTargetActivitiesByIC50 ( str target_id) 
Подсчитывает количество активностей для указанной цели (target_id) на основе IC50.

Args:
    target_id (str): Идентификатор цели из базы ChEMBL.

Returns:
    int: Количество активностей типа IC50 для указанной цели.
67def CountTargetActivitiesByIC50(target_id: str) -> int:
68 """
69 Подсчитывает количество активностей для указанной цели (target_id) на основе IC50.
70
71 Args:
72 target_id (str): Идентификатор цели из базы ChEMBL.
73
74 Returns:
75 int: Количество активностей типа IC50 для указанной цели.
76 """
77
78 return len(QuerySetActivitiesByIC50(target_id)) # type: ignore
79
80
Here is the call graph for this function:

◆ CountTargetActivitiesByKi()

int functions.CountTargetActivitiesByKi ( str target_id) 
Подсчитывает количество активностей для указанной цели (target_id) на основе Ki.

Args:
    target_id (str): Идентификатор цели из базы ChEMBL.

Returns:
    int: Количество активностей типа Ki для указанной цели.
81def CountTargetActivitiesByKi(target_id: str) -> int:
82 """
83 Подсчитывает количество активностей для указанной цели (target_id) на основе Ki.
84
85 Args:
86 target_id (str): Идентификатор цели из базы ChEMBL.
87
88 Returns:
89 int: Количество активностей типа Ki для указанной цели.
90 """
91
92 return len(QuerySetActivitiesByKi(target_id)) # type: ignore
93
94
Here is the call graph for this function:

◆ DownloadCellLinesFromIdList()

functions.DownloadCellLinesFromIdList ( ) 
Скачивает данные о клеточных линиях из ChEMBL по списку идентификаторов,
добавляет информацию об активностях IC50 и GI50, проводит первичный анализ
и сохраняет результаты в CSV-файл.
157def DownloadCellLinesFromIdList():
158 """
159 Скачивает данные о клеточных линиях из ChEMBL по списку идентификаторов,
160 добавляет информацию об активностях IC50 и GI50, проводит первичный анализ
161 и сохраняет результаты в CSV-файл.
162 """
163
164 # получаем конфигурацию для клеточных линий.
165 cell_lines_config: Config = config["ChEMBL_download_cell_lines"]
166
167 v_logger.info("Downloading cell_lines...", LogMode.VERBOSELY)
168
169 # получаем клеточные линии по списку id.
170 cell_lines_with_ids: QuerySet = QuerySetCellLinesFromIdList(
171 cell_lines_config["id_list"]
172 )
173
174 # если список id пуст, получаем все клеточные линии.
175 if cell_lines_config["id_list"] == []:
176 cell_lines_with_ids = QuerySetAllCellLines()
177
178 v_logger.info(f"Amount: {len(cell_lines_with_ids)}") # type: ignore
179 v_logger.success("Downloading cell_lines!", LogMode.VERBOSELY)
180 v_logger.info("Collecting cell_lines to pandas.DataFrame...", LogMode.VERBOSELY)
181
182 # добавляем информацию об активностях IC50 и GI50.
183 data_frame = AddedIC50andGI50ToCellLinesDF(pd.DataFrame(cell_lines_with_ids)) # type: ignore
184
185 v_logger.UpdateFormat(
186 cell_lines_config["logger_label"], cell_lines_config["logger_color"]
187 )
188
189 v_logger.success("Collecting cell_lines to pandas.DataFrame!", LogMode.VERBOSELY)
190 v_logger.info(
191 f"Collecting cell_lines to .csv file in "
192 f"'{cell_lines_config['results_folder_name']}'...",
193 LogMode.VERBOSELY,
194 )
195
196 # формируем имя файла для сохранения.
197 file_name: str = (
198 f"{cell_lines_config['results_folder_name']}/"
199 f"{cell_lines_config['results_file_name']}.csv"
200 )
201
202 # сохраняем DataFrame в CSV-файл.
203 data_frame.to_csv(file_name, sep=";", index=False)
204
205 v_logger.success(
206 f"Collecting cell_lines to .csv file in "
207 f"'{cell_lines_config['results_folder_name']}'!",
208 LogMode.VERBOSELY,
209 )
Here is the call graph for this function:

◆ DownloadCompoundsByMWRange()

functions.DownloadCompoundsByMWRange ( int less_limit,
int greater_limit,
str results_folder_name ) 
Возвращает молекулы в диапазоне молекулярной массы [less_limit;
greater_limit) из базы ChEMBL, сохраняя их в .csv файл.

Args:
    less_limit (int): нижняя граница.
    greater_limit (int): верхняя граница.
    results_folder_name (str): имя папки для закачки.
210):
211 """
212 Возвращает молекулы в диапазоне молекулярной массы [less_limit;
213 greater_limit) из базы ChEMBL, сохраняя их в .csv файл.
214
215 Args:
216 less_limit (int): нижняя граница.
217 greater_limit (int): верхняя граница.
218 results_folder_name (str): имя папки для закачки.
219 """
220
221 v_logger.info(
222 f"Downloading molecules with mw in range [{less_limit}, {greater_limit})...",
223 LogMode.VERBOSELY,
224 )
225
226 # получаем молекулы в заданном диапазоне молекулярной массы.
227 mols_in_mw_range: QuerySet = QuerySetCompoundsByMWRange(less_limit, greater_limit)
228
229 v_logger.info(
230 f"Amount: {len(mols_in_mw_range)}", # type: ignore
231 LogMode.VERBOSELY,
232 )
233 v_logger.success(
234 f"Downloading molecules with mw in range [{less_limit}, {greater_limit})!",
235 LogMode.VERBOSELY,
236 )
237
238 v_logger.info("Collecting molecules to pandas.DataFrame...", LogMode.VERBOSELY)
239
240 # преобразуем данные в DataFrame.
241 data_frame = ExpandedFromDictionariesCompoundsDF(pd.DataFrame(mols_in_mw_range)) # type: ignore
242
243 v_logger.success("Collecting molecules to pandas.DataFrame!", LogMode.VERBOSELY)
244 v_logger.info(
245 f"Collecting molecules to .csv file in '{results_folder_name}'...", LogMode.VERBOSELY
246 )
247
248 # формируем имя файла для сохранения.
249 file_name: str = f"{results_folder_name}/range_{less_limit}_{greater_limit}_mw_mols.csv"
250
251 # сохраняем DataFrame в .csv файл.
252 data_frame.to_csv(file_name, sep=";", index=False)
253
254 v_logger.success(
255 f"Collecting molecules to .csv file in '{results_folder_name}'!", LogMode.VERBOSELY
256 )
257
258
Here is the call graph for this function:

◆ DownloadCompoundToxicity()

functions.DownloadCompoundToxicity ( dict compound_data,
str page_folder_name ) 
Скачиваем данные о токсичности соединения по информации из JSON PubChem
и сохраняем их в CSV-файл.

Args:
    compound_data (dict): словарь с информацией о соединении из JSON PubChem.
    page_folder_name (str): путь к директории, в которой будет сохранен файл.
162def DownloadCompoundToxicity(compound_data: dict, page_folder_name: str):
163 """
164 Скачиваем данные о токсичности соединения по информации из JSON PubChem
165 и сохраняем их в CSV-файл.
166
167 Args:
168 compound_data (dict): словарь с информацией о соединении из JSON PubChem.
169 page_folder_name (str): путь к директории, в которой будет сохранен файл.
170 """
171
172 cid: str = ""
173
174 try:
175 # пытаемся получить CID соединения.
176 cid = compound_data["LinkedRecords"]["CID"][0]
177
178 # если CID отсутствует.
179 except KeyError:
180 v_logger.warning(
181 f"No 'cid' for 'sid': {compound_data['LinkedRecords']['SID'][0]}, skip."
182 )
183 v_logger.info("-", LogMode.VERBOSELY)
184
185 return
186 # не сохраняем те соединения, у которых нет cid,
187 # так как невозможно вычислить молекулярные вес
188
189 primary_sid: int | None
190 try:
191 # пытаемся получить SID соединения.
192 primary_sid = int(compound_data["LinkedRecords"]["SID"][0])
193
194 # если SID отсутствует.
195 except KeyError:
196 primary_sid = None
197
198 # получаем данные из таблицы.
199 raw_table: str = compound_data["Data"][0]["Value"]["ExternalTableName"]
200 table_info: dict = {}
201
202 # разбираем данные таблицы.
203 for row in raw_table.split("&"):
204 key, value = row.split("=")
205 table_info[key] = value
206
207 # проверяем тип запроса.
208 if table_info["query_type"] != "sid":
209 v_logger.LogException(ValueError(f"Unknown query type at page {page_folder_name}"))
210
211 # получаем SID из данных таблицы.
212 sid = int(table_info["query"])
213
214 # проверяем соответствие SID.
215 if primary_sid != sid:
216 v_logger.warning(f"Mismatch between 'primary_sid' ({primary_sid}) and 'sid' ({sid}).")
217
218 # формируем имя файла.
219 compound_name: str = f"compound_{sid}_toxicity"
220
221 # формируем пути к файлам для разных единиц измерения.
222 compound_file_kg = f"{page_folder_name.format(unit_type='kg')}/{compound_name}"
223 compound_file_m3 = f"{page_folder_name.format(unit_type='m3')}/{compound_name}"
224
225 # если файл уже существует и скачивание пропущено, пропускаем.
226 if os.path.exists(f"{compound_file_kg}.csv") or (
227 os.path.exists(f"{compound_file_m3}.csv") and config["skip_downloaded"]
228 ):
229 v_logger.info(f"{compound_name} is already downloaded, skip.", LogMode.VERBOSELY)
230 v_logger.info("-", LogMode.VERBOSELY)
231
232 return
233
234 v_logger.info(f"Downloading {compound_name}...", LogMode.VERBOSELY)
235
236 # получаем данные о токсичности из PubChem.
237 acute_effects = GetDataFrameFromUrl(
238 GetLinkFromSid(
239 sid=sid, collection=table_info["collection"], limit=toxicity_config["limit"]
240 ),
241 toxicity_config["sleep_time"],
242 )
243
244 @ReTry()
245 def GetMolecularWeightByCid(cid: str | int) -> str:
246 """
247 Получает молекулярный вес соединения из PubChem REST API, используя его CID.
248
249 Args:
250 cid (str | int): PubChem Compound Identifier (CID) соединения.
251
252 Returns:
253 str: молекулярный вес соединения в виде строки.
254 """
255
256 # получаем молекулярный вес соединения из PubChem.
257 return GetResponse(
258 "https://pubchem.ncbi.nlm.nih.gov/rest/pug/compound/cid/"
259 f"{cid}/property/MolecularWeight/txt",
260 True,
261 None,
262 ).text.strip()
263
264 def CalcMolecularWeight(
265 df: pd.DataFrame,
266 id_column: str,
267 ) -> pd.DataFrame:
268 """
269 Вычисляет и добавляет столбец 'mw' (молекулярный вес) в pd.DataFrame.
270
271 Args:
272 df (pd.DataFrame): исходный pd.DataFrame.
273 id_column (str): название столбца, содержащего ID соединений.
274
275 Returns:
276 pd.DataFrame: модифицированный DataFrame с добавленным столбцом 'mw'.
277 """
278
279 # получаем уникальные идентификаторы соединений.
280 unique_ids = df[id_column].dropna().unique()
281
282 # если найден только один уникальный идентификатор.
283 if len(unique_ids) == 1:
284 # получаем молекулярный вес для этого идентификатора.
285 mw = GetMolecularWeightByCid(unique_ids[0])
286
287 # если молекулярный вес найден.
288 if mw is not None:
289 # добавляем столбец с молекулярным весом в DataFrame.
290 df["mw"] = mw
291
292 v_logger.info(f"Found 'mw' by '{id_column}'.", LogMode.VERBOSELY)
293
294 # если молекулярный вес не найден.
295 else:
296 v_logger.warning(
297 f"Could not retrieve molecular weight by '{id_column}' for {unique_ids[0]}."
298 )
299
300 # если идентификаторы не найдены.
301 elif len(unique_ids) == 0:
302 v_logger.warning(f"No '{id_column}' found for {unique_ids[0]}.")
303
304 # если идентификаторов несколько.
305 else:
306 v_logger.warning(f"Non-unique 'mw' by {id_column} for {unique_ids[0]}.")
307
308 # применяем функцию получения молекулярного веса к каждому id.
309 df["mw"] = df[id_column].apply(GetMolecularWeightByCid)
310
311 # если некоторые значения молекулярного веса не найдены.
312 if df["mw"].isnull().any():
313 v_logger.warning(f"Some 'mw' could not be retrieved by {id_column}.")
314
315 return df
316
317 def ExtractDoseAndTime(df: pd.DataFrame, valid_units: list[str]) -> pd.DataFrame:
318 """
319 Преобразует DataFrame с данными о дозировках, извлекая числовое
320 значение, единицу измерения и период времени.
321
322 Args:
323 df (pd.DataFrame): таблица с колонкой "dose", содержащей
324 информацию о дозировках.
325 valid_units (list[str]): список допустимых единиц измерения дозы.
326
327 Returns:
328 DataFrame с тремя новыми колонками: "numeric_dose", "dose_value",
329 "time_period".
330 """
331
332 df = df.copy()
333
334 def ExtractDose(
335 dose_str: str, mw: float
336 ) -> tuple[float | None, str | None, str | None]:
337 """
338 Извлекает дозу, единицу измерения и период времени из строки
339 дозировки.
340
341 Args:
342 dose_str (str): строка, содержащая информацию о дозировке.
343 mw (float): молекулярная масса соединения.
344
345 Returns:
346 tuple[float | None, str | None, str | None]: кортеж, содержащий:
347 - числовую дозу (float или None, если извлечь не удалось).
348 - единицу измерения дозы (str или None, если извлечь не удалось).
349 - период времени (str или None, если извлечь не удалось).
350 """
351
352 # если в строке нет пробелов, возвращаем None.
353 if " " not in dose_str:
354 return None, None, None
355
356 num_dose: float | str | None = None
357 dose_unit: str | None = None
358 time_per: str | None = None
359
360 try:
361 # если строка дозировки содержит не два элемента, возвращаем None.
362 if len(dose_str.split(" ")) != len(
363 ["dose_amount_str", "dose_and_time"]
364 ): # короче, != 2
365 return None, None, None
366
367 # разделяем строку на количество дозы и единицы измерения.
368 dose_amount_str, dose_and_time = dose_str.split(" ")
369 # преобразуем количество дозы в число.
370 num_dose = float(dose_amount_str)
371
372 # если не удалось преобразовать количество дозы в число.
373 except ValueError:
374 v_logger.warning(f"Unsupported dose string: {dose_str}", LogMode.VERBOSELY)
375 return None, None, None
376
377 # определяем, есть ли период времени.
378 match dose_str.count("/"):
379 case 1: # нету time period или это pp*/time
380 # если строка начинается с "p", это "pp*/time".
381 if dose_and_time.startswith("p"):
382 dose_unit, time_per = dose_and_time.split("/")
383 else:
384 dose_unit = dose_and_time
385 time_per = None
386
387 case 2: # есть time period
388 # извлекаем единицу измерения и период времени.
389 dose_unit = "/".join(dose_and_time.split("/")[:-1])
390 time_per = dose_and_time.split("/")[-1]
391
392 case _:
393 return None, None, None
394
395 # если единица измерения не поддерживается.
396 if dose_unit not in valid_units:
397 v_logger.warning(
398 f"Unsupported dose_unit (non-valid): {dose_unit}", LogMode.VERBOSELY
399 )
400 return None, None, None
401
402 unit_prefix: str = dose_unit
403 unit_suffix: str = "m3"
404
405 # если единица измерения содержит "/", разделяем ее.
406 if dose_unit.count("/") > 0:
407 unit_prefix, unit_suffix = dose_unit.split("/")
408
409 # если суффикс не поддерживается.
410 if unit_suffix not in ("kg", "m3"):
411 v_logger.warning(
412 f"Unsupported dose_unit (suffix): {dose_unit}", LogMode.VERBOSELY
413 )
414 return None, None, None
415
416 unit_prefix = unit_prefix.lower()
417
418 # словарь с коэффициентами перевода единиц измерения.
419 conversions: dict[str, float] = {
420 "mg": 1,
421 "gm": 1000,
422 "g": 1000,
423 "ng": 0.000001,
424 "ug": 0.001,
425 "ml": 1000,
426 "nl": 0.001, # 1000 * 0.000001
427 "ul": 1, # 1000 * 0.001
428 "ppm": 24.45 / mw, # 1 ppm = 1 mg/m3 * 24.45/mw
429 "ppb": 0.001 * 24.45 / mw, # 1 ppb = 0.001 ppm
430 "pph": 1 / 60 * 24.45 / mw, # 1 pph = 1/60 ppm
431 }
432
433 # переводим известные единицы к "mg/kg" и "mg/m3".
434 if unit_prefix in conversions:
435 num_dose *= conversions[unit_prefix]
436 dose_unit = "mg/" + unit_suffix
437
438 # если префикс не поддерживается.
439 else:
440 v_logger.warning(
441 f"Unsupported dose_unit (prefix): {dose_unit}", LogMode.VERBOSELY
442 )
443 return None, None, None
444
445 return num_dose, dose_unit, time_per
446
447 # применяем функцию извлечения дозы к каждой строке DataFrame.
448 df[["numeric_dose", "dose_units", "time_period"]] = df.apply(
449 lambda row: pd.Series(ExtractDose(row["dose"], row["mw"])), axis=1
450 )
451
452 # удаляем исходный столбец "dose" и переименовываем новый.
453 df = df.drop(columns=["dose"]).rename(columns={"numeric_dose": "dose"})
454
455 return df
456
457 def SaveMolfileWithToxicityToSDF(df: pd.DataFrame, unit_type: str):
458 """
459 Сохраняет molfile соединения с данными о токсичности в SDF-файл.
460
461 Args:
462 df (pd.DataFrame): DataFrame, содержащий данные о токсичности соединения.
463 unit_type (str): тип единиц измерения (например, "kg" или "m3").
464 """
465
466 # создаем пустой DataFrame для хранения данных.
467 listed_df = pd.DataFrame()
468
469 # итерируемся по столбцам DataFrame.
470 for column_name in df.columns:
471 # получаем данные столбца в виде списка.
472 full_column_data = df[column_name].tolist()
473
474 # добавляем данные столбца в новый DataFrame.
475 listed_df[column_name] = [full_column_data]
476 # если элемент уникален.
477 if len(DedupedList(full_column_data)) == 1:
478 # то записываем только его.
479 listed_df.loc[0, column_name] = full_column_data[0]
480
481 # сохраняем molfile в SDF-файл.
482 SaveMolfilesToSDF(
483 data=pd.DataFrame({"cid": [cid], "molfile": [GetMolfileFromCID(cid)]}),
484 file_name=(
485 f"{toxicity_config['molfiles_folder_name']}/{compound_name}_{unit_type}"
486 ),
487 molecule_id_column_name="cid",
488 extra_data=listed_df,
489 indexing_lists=True,
490 )
491
492 def SaveToxicityUnitSpecification(
493 compound_file_unit: str,
494 unit_str: str,
495 valid_units: list[str],
496 acute_effects: pd.DataFrame,
497 ):
498 """
499 Фильтрует, преобразует и сохраняет данные о токсичности для указанного
500 типа единиц измерения.
501
502 Args:
503 compound_file_unit (str): имя файла для сохранения (без расширения).
504 unit_str (str): тип единиц измерения ("kg" или "m3").
505 valid_units (list[str]): список допустимых единиц измерения.
506 acute_effects (pd.DataFrame): DataFrame с данными о токсичности.
507 """
508
509 v_logger.info(
510 f"Filtering by {list(filtering_config[unit_str].keys())}...", LogMode.VERBOSELY
511 )
512
513 acute_effects_unit: pd.DataFrame = acute_effects.copy()
514
515 # фильтрация данных по тем признакам, что есть в `filtering_config[unit_str]`
516 for key in filtering_config[unit_str].keys():
517 if len(filtering_config[unit_str][key]) != 0:
518 acute_effects_unit = acute_effects_unit[
519 acute_effects_unit[key].isin(filtering_config[unit_str][key])
520 ]
521
522 v_logger.success(
523 f"Filtering by {list(filtering_config[unit_str].keys())}!", LogMode.VERBOSELY
524 )
525
526 v_logger.info(f"Filtering 'dose' in {unit_str}...", LogMode.VERBOSELY)
527
528 # если DataFrame пустой, пропускаем.
529 if acute_effects_unit.empty:
530 v_logger.warning(
531 f"{compound_name}_{unit_str} is empty, no need saving, skip.", LogMode.VERBOSELY
532 )
533 return
534
535 # если столбец "dose" присутствует.
536 if "dose" in acute_effects_unit.columns:
537 # извлекаем дозу, единицы измерения и время.
538 acute_effects_unit = ExtractDoseAndTime(acute_effects_unit, valid_units)
539
540 # преобразуем значения столбца "dose" в числовой формат.
541 acute_effects_unit["dose"] = pd.to_numeric(
542 acute_effects_unit["dose"], errors="coerce"
543 )
544
545 # если столбец "dose" отсутствует.
546 else:
547 v_logger.warning(f"No dose in {compound_name}_{unit_str}, skip.", LogMode.VERBOSELY)
548 return
549
550 # если DataFrame пустой, пропускаем.
551 if acute_effects_unit.empty:
552 v_logger.warning(
553 f"{compound_name}_{unit_str} is empty, no need saving, skip.", LogMode.VERBOSELY
554 )
555 return
556
557 # если столбцы "dose" или "dose_units" отсутствуют.
558 if (
559 "dose" not in acute_effects_unit.columns
560 or "dose_units" not in acute_effects_unit.columns
561 ):
562 v_logger.warning(
563 f"{compound_name}_{unit_str} misses 'dose' or 'dose_units', skip.",
564 LogMode.VERBOSELY,
565 )
566 return
567
568 v_logger.success(f"Filtering 'dose' in {unit_str}!", LogMode.VERBOSELY)
569
570 v_logger.info(f"Adding 'pLD' to {compound_name}_{unit_str}...", LogMode.VERBOSELY)
571
572 # вычисляем pLD.
573 acute_effects_unit["pLD"] = -np.log10(
574 (acute_effects_unit["dose"] / acute_effects_unit["mw"]) / 1000000
575 )
576
577 v_logger.success(f"Adding 'pLD' to {compound_name}_{unit_str}!", LogMode.VERBOSELY)
578
579 v_logger.info(f"Saving {compound_name}_{unit_str} to .csv...", LogMode.VERBOSELY)
580
581 # заменяем пустые строки на NaN.
582 acute_effects_unit = acute_effects_unit.replace("", np.nan)
583 # удаляем столбцы, состоящие только из NaN.
584 acute_effects_unit = acute_effects_unit.dropna(axis=1, how="all")
585
586 # проверяем наличие дозы и единиц ее измерения.
587 if (
588 "dose" in acute_effects_unit.columns and "dose_units" in acute_effects_unit.columns
589 ):
590 # оставляем только строки, в которых есть информация о дозе и
591 # единицах измерения.
592 acute_effects_unit = acute_effects_unit[
593 (acute_effects_unit["dose_units"].notna()) & (acute_effects_unit["dose"].notna())
594 ]
595
596 # если нет нужных столбцов.
597 else:
598 v_logger.warning(
599 f"{compound_name}_{unit_str} misses 'dose' or 'dose_units', skip.",
600 LogMode.VERBOSELY,
601 )
602 return
603
604 # сохраняем DataFrame в CSV-файл.
605 acute_effects_unit.to_csv(f"{compound_file_unit}.csv", sep=";", index=False, mode="w")
606
607 v_logger.success(f"Saving {compound_name}_{unit_str} to .csv!", LogMode.VERBOSELY)
608
609 # если необходимо скачивать соединения в SDF.
610 if toxicity_config["download_compounds_sdf"]:
611 v_logger.info(f"Saving {compound_name}_{unit_str} to .sdf...", LogMode.VERBOSELY)
612
613 # создаем директорию для SDF-файлов.
614 os.makedirs(toxicity_config["molfiles_folder_name"], exist_ok=True)
615
616 # сохраняем molfile в SDF-файл.
617 SaveMolfileWithToxicityToSDF(acute_effects_unit, unit_str)
618
619 v_logger.success(f"Saving {compound_name}_{unit_str} to .sdf!", LogMode.VERBOSELY)
620
621 v_logger.info("Adding 'mw'...", LogMode.VERBOSELY)
622
623 # добавляем столбец с молекулярным весом.
624 acute_effects = CalcMolecularWeight(acute_effects, "cid")
625
626 try:
627 # преобразуем значения столбца "mw" в числовой формат.
628 acute_effects["mw"] = pd.to_numeric(acute_effects["mw"], errors="coerce")
629
630 v_logger.success("Adding 'mw'!", LogMode.VERBOSELY)
631
632 # если столбец "mw" не найден.
633 except KeyError:
634 v_logger.warning(f"No 'mw' for {compound_name}, skip.")
635 return
636
637 v_logger.info("~", LogMode.VERBOSELY)
638
639 # сохраняем данные о токсичности для единиц измерения "kg".
640 SaveToxicityUnitSpecification(
641 compound_file_unit=compound_file_kg,
642 unit_str="kg",
643 valid_units=["gm/kg", "g/kg", "mg/kg", "ug/kg", "ng/kg", "mL/kg", "uL/kg", "nL/kg"],
644 acute_effects=acute_effects,
645 )
646
647 v_logger.info("·", LogMode.VERBOSELY)
648
649 # сохраняем данные о токсичности для единиц измерения "m3".
650 SaveToxicityUnitSpecification(
651 compound_file_unit=compound_file_m3,
652 unit_str="m3",
653 valid_units=[
654 "gm/m3",
655 "g/m3",
656 "mg/m3",
657 "ug/m3",
658 "ng/m3",
659 "mL/m3",
660 "uL/m3",
661 "nL/m3",
662 "ppm",
663 "ppb",
664 "pph",
665 ],
666 acute_effects=acute_effects,
667 )
668
669 v_logger.info("·", LogMode.VERBOSELY)
670 v_logger.success(f"Downloading {compound_name}!", LogMode.VERBOSELY)
671 v_logger.info("-", LogMode.VERBOSELY)
Here is the call graph for this function:

◆ DownloadTargetsFromIdList()

functions.DownloadTargetsFromIdList ( ) 
Скачивает данные о целевых белках (targets) из ChEMBL по списку
идентификаторов, добавляет информацию об активностях IC50 и Ki, проводит
первичный анализ и сохраняет результаты в CSV-файл.
211def DownloadTargetsFromIdList():
212 """
213 Скачивает данные о целевых белках (targets) из ChEMBL по списку
214 идентификаторов, добавляет информацию об активностях IC50 и Ki, проводит
215 первичный анализ и сохраняет результаты в CSV-файл.
216 """
217
218 # получаем конфигурацию для скачивания целей.
219 targets_config: Config = config["ChEMBL_download_targets"]
220
221 v_logger.info("Downloading targets...", LogMode.VERBOSELY)
222
223 # получаем цели по списку id.
224 targets_with_ids: QuerySet = QuerySetTargetsFromIdList(targets_config["id_list"])
225
226 # если список id пуст, получаем все цели.
227 if targets_config["id_list"] == []:
228 targets_with_ids = QuerySetAllTargets()
229
230 v_logger.info(f"Amount: {len(targets_with_ids)}") # type: ignore
231 v_logger.success("Downloading targets!", LogMode.VERBOSELY)
232 v_logger.info("Collecting targets to pandas.DataFrame..", LogMode.VERBOSELY)
233
234 # добавляем информацию об активностях IC50 и Ki.
235 data_frame = AddedIC50andKiToTargetsDF(
236 ExpandedFromDictionariesTargetsDF(
237 pd.DataFrame(targets_with_ids) # type: ignore
238 )
239 )
240
241 v_logger.UpdateFormat(targets_config["logger_label"], targets_config["logger_color"])
242
243 v_logger.success("Collecting targets to pandas.DataFrame!", LogMode.VERBOSELY)
244 v_logger.info(
245 f"Collecting targets to .csv file in '{targets_config['results_folder_name']}'...",
246 LogMode.VERBOSELY,
247 )
248
249 # формируем имя файла.
250 file_name: str = (
251 f"{targets_config['results_folder_name']}/{targets_config['results_file_name']}.csv"
252 )
253
254 # сохраняем DataFrame в CSV-файл.
255 data_frame.to_csv(file_name, sep=";", index=False)
256
257 v_logger.success(
258 f"Collecting targets to .csv file in '{targets_config['results_folder_name']}'!",
259 LogMode.VERBOSELY,
260 )
Here is the call graph for this function:

◆ ExpandedFromDictionariesCompoundsDF()

pd.DataFrame functions.ExpandedFromDictionariesCompoundsDF ( pd.DataFrame data) 
Избавляет pd.DataFrame от словарей и списков словарей в столбцах, разбивая
их на подстолбцы.

Args:
    data (pd.DataFrame): исходный pd.DataFrame.

Returns:
    pd.DataFrame: "раскрытый" pd.DataFrame.
52def ExpandedFromDictionariesCompoundsDF(data: pd.DataFrame) -> pd.DataFrame:
53 """
54 Избавляет pd.DataFrame от словарей и списков словарей в столбцах, разбивая
55 их на подстолбцы.
56
57 Args:
58 data (pd.DataFrame): исходный pd.DataFrame.
59
60 Returns:
61 pd.DataFrame: "раскрытый" pd.DataFrame.
62 """
63
64 def ExtractedValuesFromColumn(
65 df: pd.DataFrame, column_name: str, key: str, is_list: bool = True
66 ) -> pd.Series:
67 """
68 Извлекает значения из указанного столбца DataFrame на основе заданного
69 ключа.
70
71 Args:
72 df (pd.DataFrame): DataFrame, из которого нужно извлечь значения.
73 column_name (str): название столбца, из которого нужно извлечь
74 значения.
75 key (str): ключ, по которому нужно извлечь значения из словарей.
76 is_list (bool, optional): флаг, указывающий, является ли значение
77 в столбце списком словарей.
78
79 Returns:
80 pd.Series: Series, содержащий извлеченные значения.
81 """
82
83 # если значение в столбце - список словарей.
84 if is_list:
85 return df[column_name].apply(lambda x: [d[key] for d in x] if x else [])
86
87 # если значение в столбце - не список словарей.
88 return [item[key] if isinstance(item, dict) else None for item in df[column_name]] # type: ignore
89
90 # извлекаем значения из различных столбцов DataFrame.
91 exposed_data = pd.DataFrame(
92 {
93 # ! cross_references
94 "xref_id": ExtractedValuesFromColumn(data, "cross_references", "xref_id"),
95 "xref_name": ExtractedValuesFromColumn(data, "cross_references", "xref_name"),
96 "xref_src": ExtractedValuesFromColumn(data, "cross_references", "xref_src"),
97 # ! molecule_hierarchy
98 "active_chembl_id": ExtractedValuesFromColumn(
99 data, "molecule_hierarchy", "active_chembl_id", is_list=False
100 ),
101 "molecule_chembl_id": ExtractedValuesFromColumn(
102 data, "molecule_hierarchy", "molecule_chembl_id", is_list=False
103 ),
104 "parent_chembl_id": ExtractedValuesFromColumn(
105 data, "molecule_hierarchy", "parent_chembl_id", is_list=False
106 ),
107 # ! molecule_properties
108 "alogp": ExtractedValuesFromColumn(
109 data, "molecule_properties", "alogp", is_list=False
110 ),
111 "aromatic_rings": ExtractedValuesFromColumn(
112 data, "molecule_properties", "aromatic_rings", is_list=False
113 ),
114 "cx_logd": ExtractedValuesFromColumn(
115 data, "molecule_properties", "cx_logd", is_list=False
116 ),
117 "cx_logp": ExtractedValuesFromColumn(
118 data, "molecule_properties", "cx_logp", is_list=False
119 ),
120 "cx_most_apka": ExtractedValuesFromColumn(
121 data, "molecule_properties", "cx_most_apka", is_list=False
122 ),
123 "cx_most_bpka": ExtractedValuesFromColumn(
124 data, "molecule_properties", "cx_most_bpka", is_list=False
125 ),
126 "full_molformula": ExtractedValuesFromColumn(
127 data, "molecule_properties", "full_molformula", is_list=False
128 ),
129 "full_mwt": ExtractedValuesFromColumn(
130 data, "molecule_properties", "full_mwt", is_list=False
131 ),
132 "hba": ExtractedValuesFromColumn(data, "molecule_properties", "hba", is_list=False),
133 "hba_lipinski": ExtractedValuesFromColumn(
134 data, "molecule_properties", "hba_lipinski", is_list=False
135 ),
136 "hbd": ExtractedValuesFromColumn(data, "molecule_properties", "hbd", is_list=False),
137 "hbd_lipinski": ExtractedValuesFromColumn(
138 data, "molecule_properties", "hbd_lipinski", is_list=False
139 ),
140 "heavy_atoms": ExtractedValuesFromColumn(
141 data, "molecule_properties", "heavy_atoms", is_list=False
142 ),
143 "molecular_species": ExtractedValuesFromColumn(
144 data, "molecule_properties", "molecular_species", is_list=False
145 ),
146 "mw_freebase": ExtractedValuesFromColumn(
147 data, "molecule_properties", "mw_freebase", is_list=False
148 ),
149 "mw_monoisotopic": ExtractedValuesFromColumn(
150 data, "molecule_properties", "mw_monoisotopic", is_list=False
151 ),
152 "np_likeness_score": ExtractedValuesFromColumn(
153 data, "molecule_properties", "np_likeness_score", is_list=False
154 ),
155 "num_lipinski_ro5_violations": ExtractedValuesFromColumn(
156 data, "molecule_properties", "num_lipinski_ro5_violations", is_list=False
157 ),
158 "num_ro5_violations": ExtractedValuesFromColumn(
159 data, "molecule_properties", "num_ro5_violations", is_list=False
160 ),
161 "psa": ExtractedValuesFromColumn(data, "molecule_properties", "psa", is_list=False),
162 "qed_weighted": ExtractedValuesFromColumn(
163 data, "molecule_properties", "qed_weighted", is_list=False
164 ),
165 "ro3_pass": ExtractedValuesFromColumn(
166 data, "molecule_properties", "ro3_pass", is_list=False
167 ),
168 "rtb": ExtractedValuesFromColumn(data, "molecule_properties", "rtb", is_list=False),
169 # ! molecule_structures
170 "canonical_smiles": ExtractedValuesFromColumn(
171 data, "molecule_structures", "canonical_smiles", is_list=False
172 ),
173 "molfile": ExtractedValuesFromColumn(
174 data, "molecule_structures", "molfile", is_list=False
175 ),
176 "standard_inchi": ExtractedValuesFromColumn(
177 data, "molecule_structures", "standard_inchi", is_list=False
178 ),
179 "standard_inchi_key": ExtractedValuesFromColumn(
180 data, "molecule_structures", "standard_inchi_key", is_list=False
181 ),
182 # ! molecule_synonyms
183 "molecule_synonym": ExtractedValuesFromColumn(
184 data, "molecule_synonyms", "molecule_synonym"
185 ),
186 "syn_type": ExtractedValuesFromColumn(data, "molecule_synonyms", "syn_type"),
187 "synonyms": ExtractedValuesFromColumn(data, "molecule_synonyms", "synonyms"),
188 }
189 )
190
191 # удаляем исходные столбцы со словарями и списками словарей.
192 data = data.drop(
193 [
194 "cross_references",
195 "molecule_hierarchy",
196 "molecule_properties",
197 "molecule_structures",
198 "molecule_synonyms",
199 ],
200 axis=1,
201 )
202
203 # объединяем исходный DataFrame с извлеченными значениями.
204 return pd.concat([data, exposed_data], axis=1)
205
206
207@ReTry(attempts_amount=1)
Here is the caller graph for this function:

◆ ExpandedFromDictionariesTargetsDF()

pd.DataFrame functions.ExpandedFromDictionariesTargetsDF ( pd.DataFrame data) 
Избавляет pd.DataFrame от словарей и списков словарей в столбцах, разбивая
их на подстолбцы.

Args:
    data (pd.DataFrame): исходный pd.DataFrame.

Returns:
    pd.DataFrame: "раскрытый" pd.DataFrame.
54def ExpandedFromDictionariesTargetsDF(data: pd.DataFrame) -> pd.DataFrame:
55 """
56 Избавляет pd.DataFrame от словарей и списков словарей в столбцах, разбивая
57 их на подстолбцы.
58
59 Args:
60 data (pd.DataFrame): исходный pd.DataFrame.
61
62 Returns:
63 pd.DataFrame: "раскрытый" pd.DataFrame.
64 """
65
66 def ExtractedValuesFromColumn(
67 df: pd.DataFrame, column_name: str, key: str
68 ) -> pd.Series:
69 """
70 Извлекает значения из указанного столбца DataFrame, который содержит
71 списки словарей, на основе заданного ключа.
72
73 Args:
74 df (pd.DataFrame): DataFrame, из которого нужно извлечь значения.
75 column_name (str): название столбца, содержащего списки словарей.
76 key (str): ключ, по которому нужно извлечь значения из словарей.
77
78 Returns:
79 pd.Series: Series, содержащий списки извлеченных значений.
80 """
81
82 # извлекаем значения из указанного столбца DataFrame.
83 return df[column_name].apply(lambda x: [d[key] for d in x] if x else [])
84
85 # извлекаем значения из столбца cross_references.
86 exposed_data = pd.DataFrame(
87 {
88 "xref_id": ExtractedValuesFromColumn(data, "cross_references", "xref_id"),
89 "xref_name": ExtractedValuesFromColumn(data, "cross_references", "xref_name"),
90 "xref_src": ExtractedValuesFromColumn(data, "cross_references", "xref_src"),
91 }
92 )
93
94 # избавляемся от списков, так как в них находятся одиночные словари.
95 data["target_components"] = data["target_components"].apply(
96 lambda x: x[0]
97 if x
98 else {
99 "accession": None,
100 "component_description": None,
101 "component_id": None,
102 "component_type": None,
103 "relationship": None,
104 "target_component_synonyms": [],
105 "target_component_xrefs": [],
106 }
107 )
108
109 # создаем DataFrame из столбца target_components.
110 target_components_data = pd.DataFrame(data["target_components"].values.tolist())
111
112 # извлекаем значения из столбца target_component_synonyms и
113 # target_component_xrefs.
114 exposed_target_components_data = pd.DataFrame(
115 {
116 # ! target_component_synonyms
117 "component_synonym": ExtractedValuesFromColumn(
118 target_components_data, "target_component_synonyms", "component_synonym"
119 ),
120 "syn_type": ExtractedValuesFromColumn(
121 target_components_data, "target_component_synonyms", "syn_type"
122 ),
123 # ! target_component_xrefs
124 "xref_id_target_component_xrefs": ExtractedValuesFromColumn(
125 target_components_data, "target_component_xrefs", "xref_id"
126 ),
127 "xref_name_target_component_xrefs": ExtractedValuesFromColumn(
128 target_components_data, "target_component_xrefs", "xref_name"
129 ),
130 "xref_src_db_target_component_xrefs": ExtractedValuesFromColumn(
131 target_components_data, "target_component_xrefs", "xref_src_db"
132 ),
133 }
134 )
135
136 # удаляем столбцы target_component_synonyms и target_component_xrefs.
137 target_components_data = target_components_data.drop(
138 ["target_component_synonyms", "target_component_xrefs"], axis=1
139 )
140 # объединяем DataFrames.
141 target_components_data = pd.concat(
142 [target_components_data, exposed_target_components_data], axis=1
143 )
144
145 # удаляем столбцы cross_references и target_components.
146 data = data.drop(["cross_references", "target_components"], axis=1)
147 # объединяем DataFrames.
148 data = pd.concat([data, exposed_data, target_components_data], axis=1)
149
150 return data
151
152
153@ReTry(attempts_amount=1)
Here is the caller graph for this function:

◆ GetDataFrameFromUrl()

pd.DataFrame functions.GetDataFrameFromUrl ( str request_url,
float sleep_time ) 
Скачивает данные из CSV-файла по URL и преобразует их в pandas.DataFrame.

Args:
    request_url (str): URL CSV-файла.
    sleep_time (float): время ожидания перед повторной попыткой в секундах.

Returns:
    pd.DataFrame: DataFrame, содержащий данные из CSV-файла.
88def GetDataFrameFromUrl(request_url: str, sleep_time: float) -> pd.DataFrame:
89 """
90 Скачивает данные из CSV-файла по URL и преобразует их в pandas.DataFrame.
91
92 Args:
93 request_url (str): URL CSV-файла.
94 sleep_time (float): время ожидания перед повторной попыткой в секундах.
95
96 Returns:
97 pd.DataFrame: DataFrame, содержащий данные из CSV-файла.
98 """
99
100 # получаем ответ на запрос.
101 res = GetResponse(request_url, True, sleep_time)
102
103 # определяем кодировку из заголовков ответа.
104 if res.encoding is None:
105 res.encoding = "utf-8" # (UTF-8, если кодировка не указана)
106
107 # читаем CSV из ответа и преобразуем в DataFrame.
108 return pd.read_csv(StringIO(res.content.decode(res.encoding)))
109
110
Here is the call graph for this function:
Here is the caller graph for this function:

◆ GetLinkFromSid()

str functions.GetLinkFromSid ( int sid,
str collection,
int limit ) 
Формируем URL для скачивания данных из PubChem SDQ API по SID (Structure ID).

Args:
    sid (int): SID соединения.
    collection (str): коллекция для поиска.
    limit (int): максимальное количество возвращаемых записей.

Returns:
    str: URL для скачивания данных.
111def GetLinkFromSid(sid: int, collection: str, limit: int) -> str:
112 """
113 Формируем URL для скачивания данных из PubChem SDQ API по SID (Structure ID).
114
115 Args:
116 sid (int): SID соединения.
117 collection (str): коллекция для поиска.
118 limit (int): максимальное количество возвращаемых записей.
119
120 Returns:
121 str: URL для скачивания данных.
122 """
123
124 def QueryDictToStr(query: dict[str, str]) -> str:
125 """
126 Преобразует словарь с параметрами запроса в строку запроса URL-encoded.
127
128 Args:
129 query (dict[str, str]): словарь с параметрами запроса.
130
131 Returns:
132 str: строка запроса в формате "query={JSON-encoded query}".
133 Пустая строка, если словарь пуст.
134 """
135
136 # если словарь пуст, возвращаем пустую строку.
137 if not query:
138 return ""
139
140 # преобразуем словарь в строку запроса.
141 return f"query={urllib.parse.quote(json.dumps(query))}"
142
143 # формируем словарь с параметрами запроса.
144 query = {
145 "download": "*",
146 "collection": f"{collection}",
147 # "order": ["relevancescore,desc"],
148 "limit": f"{limit}",
149 "where": {"ands": [{"sid": f"{sid}"}]},
150 }
151
152 # формируем URL для запроса.
153 start = "https://pubchem.ncbi.nlm.nih.gov/sdq/sdqagent.cgi?infmt=json&outfmt=csv"
154
155 return start + "&" + QueryDictToStr(query)
156
157
158# MARK: DownloadCompoundToxicity
159
160
161@ReTry(attempts_amount=1)
Here is the caller graph for this function:

◆ GetMolfileFromCID()

str functions.GetMolfileFromCID ( str cid,
float | None sleep_time = toxicity_config["sleep_time"] ) 
Возвращает molfile-строку из GET-запроса для соединения с cid из базы PubChem.

Args:
    cid (str): CID соединения.
    sleep_time (float | None, optional): время ожидания перед повторной попыткой
    в секундах. Defaults to toxicity_config["sleep_time"].

Returns:
    str: molfile-строка.
59) -> str:
60 """
61 Возвращает molfile-строку из GET-запроса для соединения с cid из базы PubChem.
62
63 Args:
64 cid (str): CID соединения.
65 sleep_time (float | None, optional): время ожидания перед повторной попыткой
66 в секундах. Defaults to toxicity_config["sleep_time"].
67
68 Returns:
69 str: molfile-строка.
70 """
71
72 # получаем molfile соединения из PubChem.
73 molfile: str = GetResponse(
74 "https://pubchem.ncbi.nlm.nih.gov/rest/pug/compound/CID/"
75 f"{cid}/record/SDF?record_type=2d",
76 True,
77 sleep_time,
78 ).text
79
80 v_logger.info(
81 f"Return molfile (len: {len(molfile)}) for cid: {cid}.", LogMode.VERBOSELY
82 )
83
84 # очищаем molfile от лишних символов.
85 return molfile[molfile.find("\n") :].replace("$$$$", "").rstrip()
86
87
Here is the call graph for this function:
Here is the caller graph for this function:

◆ GetRawCellLinesData()

functions.GetRawCellLinesData ( str file_id,
str output_path,
bool print_to_console ) 
Скачивает zip-файл из Google.Drive,
извлекает его содержимое, а затем удаляет zip-файл.

Args:
    file_id: ID файла в Google Drive.
    output_path: путь к каталогу, куда будут помещены извлеченные файлы.
    print_to_console (bool): нужно ли выводить логирование в консоль.
51def GetRawCellLinesData(file_id: str, output_path: str, print_to_console: bool):
52 """
53 Скачивает zip-файл из Google.Drive,
54 извлекает его содержимое, а затем удаляет zip-файл.
55
56 Args:
57 file_id: ID файла в Google Drive.
58 output_path: путь к каталогу, куда будут помещены извлеченные файлы.
59 print_to_console (bool): нужно ли выводить логирование в консоль.
60 """
61
62 os.makedirs(output_path, exist_ok=True)
63
64 url = f"https://drive.google.com/uc?id={file_id}&export=download"
65
66 zip_file_path = f"{output_path}.zip"
67 gdown.download(url, zip_file_path, quiet=(not print_to_console))
68
69 with zipfile.ZipFile(zip_file_path, "r") as zip_ref:
70 zip_ref.extractall(output_path)
71
72 os.remove(zip_file_path)
73
74
75@ReTry(attempts_amount=1)
Here is the caller graph for this function:

◆ GetResponse()

requests.Response functions.GetResponse ( str request_url,
bool stream,
float | None sleep_time = toxicity_config["sleep_time"] ) 
Отправляет GET-запрос по указанному URL, повторяет попытку в случае ошибки.

Args:
    request_url (str): URL для запроса.
    stream (bool): если True, ответ будет получен потоком.
    sleep_time (float | None, optional): время ожидания перед повторной попыткой
    в секундах. Defaults to toxicity_config["sleep_time"].

Returns:
    requests.Response: объект ответа requests.
32) -> requests.Response:
33 """
34 Отправляет GET-запрос по указанному URL, повторяет попытку в случае ошибки.
35
36 Args:
37 request_url (str): URL для запроса.
38 stream (bool): если True, ответ будет получен потоком.
39 sleep_time (float | None, optional): время ожидания перед повторной попыткой
40 в секундах. Defaults to toxicity_config["sleep_time"].
41
42 Returns:
43 requests.Response: объект ответа requests.
44 """
45
46 # ждем указанное время, если оно задано.
47 if sleep_time is not None:
48 time.sleep(sleep_time)
49
50 # отправляем GET-запрос.
51 response = requests.get(request_url, stream=stream)
52 response.raise_for_status()
53
54 return response
55
56
Here is the caller graph for this function:

◆ QuerySetActivitiesByIC50()

QuerySet functions.QuerySetActivitiesByIC50 ( str target_id) 
Возвращает QuerySet активностей для указанной цели (target_id) на основе IC50.

IC50 (Half maximal inhibitory concentration) - полумаксимальная ингибирующая
концентрация.

Args:
    target_id (str): Идентификатор цели из базы ChEMBL.

Returns:
    QuerySet: QuerySet, содержащий активности, отфильтрованные по target_id и
              типу "IC50".

Raises:
    Exception: Если не удается получить данные после нескольких попыток
               (благодаря декоратору ReTry).
19def QuerySetActivitiesByIC50(target_id: str) -> QuerySet:
20 """
21 Возвращает QuerySet активностей для указанной цели (target_id) на основе IC50.
22
23 IC50 (Half maximal inhibitory concentration) - полумаксимальная ингибирующая
24 концентрация.
25
26 Args:
27 target_id (str): Идентификатор цели из базы ChEMBL.
28
29 Returns:
30 QuerySet: QuerySet, содержащий активности, отфильтрованные по target_id и
31 типу "IC50".
32
33 Raises:
34 Exception: Если не удается получить данные после нескольких попыток
35 (благодаря декоратору ReTry).
36 """
37
38 return new_client.activity.filter( # type: ignore
39 target_chembl_id=target_id
40 ).filter(standard_type="IC50")
41
42
43@ReTry()
Here is the caller graph for this function:

◆ QuerySetActivitiesByKi()

QuerySet functions.QuerySetActivitiesByKi ( str target_id) 
Возвращает QuerySet активностей для указанной цели (target_id) на основе Ki.

Ki (Inhibition constant) - константа ингибирования.

Args:
    target_id (str): Идентификатор цели из базы ChEMBL.

Returns:
    QuerySet: QuerySet, содержащий активности, отфильтрованные по target_id и
              типу "Ki".

Raises:
    Exception: Если не удается получить данные после нескольких попыток
               (благодаря декоратору ReTry).
44def QuerySetActivitiesByKi(target_id: str) -> QuerySet:
45 """
46 Возвращает QuerySet активностей для указанной цели (target_id) на основе Ki.
47
48 Ki (Inhibition constant) - константа ингибирования.
49
50 Args:
51 target_id (str): Идентификатор цели из базы ChEMBL.
52
53 Returns:
54 QuerySet: QuerySet, содержащий активности, отфильтрованные по target_id и
55 типу "Ki".
56
57 Raises:
58 Exception: Если не удается получить данные после нескольких попыток
59 (благодаря декоратору ReTry).
60 """
61
62 return new_client.activity.filter( # type: ignore
63 target_chembl_id=target_id
64 ).filter(standard_type="Ki")
65
66
Here is the caller graph for this function:

◆ QuerySetAllCellLines()

QuerySet functions.QuerySetAllCellLines ( ) 
Возвращает все клеточные линии из базы ChEMBL.

Returns:
    QuerySet: набор всех целей
23def QuerySetAllCellLines() -> QuerySet:
24 """
25 Возвращает все клеточные линии из базы ChEMBL.
26
27 Returns:
28 QuerySet: набор всех целей
29 """
30
31 return new_client.cell_line.filter() # type: ignore
32
33
34@ReTry()
Here is the caller graph for this function:

◆ QuerySetAllTargets()

QuerySet functions.QuerySetAllTargets ( ) 
Возвращает все цели из базы ChEMBL.

Returns:
    QuerySet: набор всех целей
24def QuerySetAllTargets() -> QuerySet:
25 """
26 Возвращает все цели из базы ChEMBL.
27
28 Returns:
29 QuerySet: набор всех целей
30 """
31
32 # получаем все цели из базы ChEMBL.
33 return new_client.target.filter() # type: ignore
34
35
36@ReTry()
Here is the caller graph for this function:

◆ QuerySetCellLinesFromIdList()

QuerySet functions.QuerySetCellLinesFromIdList ( list[str] cell_line_chembl_id_list) 
Возвращает клеточные линии по списку id из базы ChEMBL.

Args:
    cell_line_chembl_id_list (list[str]): список id.

Returns:
    QuerySet: набор целей по списку id.
35def QuerySetCellLinesFromIdList(cell_line_chembl_id_list: list[str]) -> QuerySet:
36 """
37 Возвращает клеточные линии по списку id из базы ChEMBL.
38
39 Args:
40 cell_line_chembl_id_list (list[str]): список id.
41
42 Returns:
43 QuerySet: набор целей по списку id.
44 """
45
46 return new_client.cell_line.filter( # type: ignore
47 cell_chembl_id__in=cell_line_chembl_id_list
48 )
49
50
Here is the caller graph for this function:

◆ QuerySetCompoundsByMWRange()

QuerySet functions.QuerySetCompoundsByMWRange ( int less_limit,
int greater_limit ) 
Возвращает молекулы в диапазоне молекулярной массы
[less_limit; greater_limit) из базы ChEMBL.

Args:
    less_limit (int): нижняя граница.
    greater_limit (int): верхняя граница.

Raises:
    ValueError: границы должны быть больше нуля.
    ValueError: greater_limit должен быть больше less_limit.

Returns:
    QuerySet: набор молекул в диапазоне.
18def QuerySetCompoundsByMWRange(less_limit: int, greater_limit: int) -> QuerySet:
19 """
20 Возвращает молекулы в диапазоне молекулярной массы
21 [less_limit; greater_limit) из базы ChEMBL.
22
23 Args:
24 less_limit (int): нижняя граница.
25 greater_limit (int): верхняя граница.
26
27 Raises:
28 ValueError: границы должны быть больше нуля.
29 ValueError: greater_limit должен быть больше less_limit.
30
31 Returns:
32 QuerySet: набор молекул в диапазоне.
33 """
34
35 # проверяем, что границы больше нуля.
36 if greater_limit < 0 or less_limit < 0:
37 raise ValueError("QuerySetMWRangeFilter: limits should be greater zero")
38
39 # проверяем, что верхняя граница больше нижней.
40 if greater_limit < less_limit:
41 raise ValueError(
42 "QuerySetMWRangeFilter: greater_limit should be greater than less_limit"
43 )
44
45 # фильтруем молекулы по диапазону молекулярной массы.
46 return new_client.molecule.filter( # type: ignore
47 molecule_properties__mw_freebase__lt=greater_limit,
48 molecule_properties__mw_freebase__gte=less_limit,
49 )
50
51
Here is the caller graph for this function:

◆ QuerySetTargetsFromIdList()

QuerySet functions.QuerySetTargetsFromIdList ( list[str] target_chembl_id_list) 
Возвращает цели по списку id из базы ChEMBL.

Args:
    target_chembl_id_list (list[str]): список id.

Returns:
    QuerySet: набор целей по списку id.
37def QuerySetTargetsFromIdList(target_chembl_id_list: list[str]) -> QuerySet:
38 """
39 Возвращает цели по списку id из базы ChEMBL.
40
41 Args:
42 target_chembl_id_list (list[str]): список id.
43
44 Returns:
45 QuerySet: набор целей по списку id.
46 """
47
48 # получаем цели по списку id из базы ChEMBL.
49 return new_client.target.filter( # type: ignore
50 target_chembl_id__in=target_chembl_id_list
51 )
52
53
Here is the caller graph for this function:

◆ SaveChEMBLMolfilesToSDFByIdList()

functions.SaveChEMBLMolfilesToSDFByIdList ( list[str] molecule_chembl_id_list,
str file_name,
pd.DataFrame extra_data = pd.DataFrame() ) 
Сохраняет molfiles из списка id в .sdf файл.

Args:
    molecule_chembl_id_list (list[str]): список id.
    file_name (str): имя файла (без .sdf).
    extra_data (pd.DataFrame): дополнительная информация.
263):
264 """
265 Сохраняет molfiles из списка id в .sdf файл.
266
267 Args:
268 molecule_chembl_id_list (list[str]): список id.
269 file_name (str): имя файла (без .sdf).
270 extra_data (pd.DataFrame): дополнительная информация.
271 """
272
273 # если список molecule_chembl_id пуст.
274 if not molecule_chembl_id_list:
275 v_logger.warning(
276 "Molecules list is empty, nothing to save to .sdf!", LogMode.VERBOSELY
277 )
278 return
279
280 @ReTry()
281 def DataFrameMolfilesFromIdList(molecule_chembl_id_list: list[str]) -> pd.DataFrame:
282 """
283 Возвращает pd.DataFrame из molfile по каждой молекуле из списка
284 molecule_chembl_id.
285
286 Args:
287 molecule_chembl_id_list (list[str]): список id.
288
289 Returns:
290 pd.DataFrame: DataFrame, который содержит molecule_chembl_id и
291 соотв. molfile.
292 """
293
294 # фильтруем молекулы по списку id.
295 qs_data: QuerySet = new_client.molecule.filter( # type: ignore
296 molecule_chembl_id__in=molecule_chembl_id_list
297 ).only(["molecule_chembl_id", "molecule_structures"])
298
299 data = pd.DataFrame(qs_data) # type: ignore
300
301 # извлекаем molfile из структуры молекулы.
302 data["molfile"] = data["molecule_structures"].apply(
303 lambda x: x["molfile"] if isinstance(x, dict) else None
304 )
305
306 # удаляем столбец molecule_structures.
307 data = data.drop(["molecule_structures"], axis=1)
308
309 return data
310
311 v_logger.info("Collecting molfiles to pandas.DataFrame...", LogMode.VERBOSELY)
312
313 # получаем DataFrame из molfiles.
314 data = DataFrameMolfilesFromIdList(molecule_chembl_id_list)
315
316 v_logger.success("Collecting molfiles to pandas.DataFrame!", LogMode.VERBOSELY)
317
318 # сохраняем molfiles в .sdf файл.
319 SaveMolfilesToSDF(
320 data=data,
321 file_name=file_name,
322 molecule_id_column_name="molecule_chembl_id",
323 extra_data=extra_data,
324 )

Variable Documentation

◆ filtering_config

Config functions.filtering_config = toxicity_config["filtering"]

◆ toxicity_config

Config functions.toxicity_config = config["PubChem_download_toxicity"]