refactoring file_reader.py, db_file_reader.py, noSQL_db_Prisma.py, add docstrings

file_reader/db_file_reader.py

@@ -1,21 +1,25 @@
 import datetime
 from collections import defaultdict
-from file_reader.file_reader import FileReader
 
 import pandas as pd
 import pymongo
 
+from file_reader.file_reader import FileReader
+
 
 class DbFileReader(FileReader):
+    """Класс для чтения данных ПРИЗМА-32 из MongoDB базы данных, должен быть один для
+    всех модулей"""
     # __DB_URL = "mongodb://localhost:27017/"
     __amp_n_cols = []
     for i in range(1, 17):
         __amp_n_cols.append(f'amp{i}')
         __amp_n_cols.append(f'n{i}')
 
+    __slots__ = ["__db_url"]
+
     def __init__(self, cluster, single_date, db_url):
-        self.cluster = cluster
-        self.single_date = single_date
+        super().__init__(cluster, single_date)
         self.__db_url = db_url
 
     def reading_db(self) -> pd.DataFrame():
@@ -42,30 +46,27 @@ class DbFileReader(FileReader):
         return data_cl
 
     def concat_n_data(self, concat_n_df):
+        """Статический метод соединения датафреймов файлов,
+        полученных на выходе в один с добавления колонки с датой"""
         data_cl = self.reading_db()
         # noinspection PyUnresolvedReferences
-        concat_n_df = pd.concat([concat_n_df, data_cl[['Date', 'time', 'trigger'] + DbFileReader.__amp_n_cols]],
+        concat_n_df = pd.concat([concat_n_df, data_cl[['Date', 'time', 'trigger'] + self.__class__.__amp_n_cols]],
                                 ignore_index=True)
         return concat_n_df
 
     @staticmethod
-    def db_preparing_data(start_date, end_date, path_to_db):
-        concat_n_df_1 = pd.DataFrame(columns=['Date', 'time', 'trigger'] + DbFileReader.__amp_n_cols)
-        concat_n_df_2 = pd.DataFrame(columns=['Date', 'time', 'trigger'] + DbFileReader.__amp_n_cols)
+    def db_preparing_data(start_date, end_date, path_to_db, cluster):
+        """Статический метод подготовки информации для обработки из
+        базы данных ПРИЗМА-32 за определенный
+        период для определенного кластера"""
+        concat_n_df = pd.DataFrame(columns=['Date', 'time', 'trigger'] + DbFileReader.__amp_n_cols)
         for single_date in pd.date_range(start_date, end_date):
             try:
-                db_file_reader_1 = DbFileReader(cluster=1, single_date=single_date, db_url=path_to_db)
-                concat_n_df_1 = db_file_reader_1.concat_n_data(concat_n_df=concat_n_df_1)
-            except FileNotFoundError:
-                print(
-                    f"File n_{single_date.month:02}-" +
-                    f"{single_date.day:02}.{single_date.year - 2000:02}', does not exist")
-            try:
-                db_file_reader_1 = DbFileReader(cluster=2, single_date=single_date, db_url=path_to_db)
-                concat_n_df_2 = db_file_reader_1.concat_n_data(concat_n_df=concat_n_df_2)
+                db_file_reader = DbFileReader(cluster=cluster, single_date=single_date, db_url=path_to_db)
+                concat_n_df = db_file_reader.concat_n_data(concat_n_df=concat_n_df)
             except FileNotFoundError:
                 print(
-                    f"File 2n_{single_date.month:02}-" +
+                    f"File {cluster}n_{single_date.month:02}-" +
                     f"{single_date.day:02}.{single_date.year - 2000:02}', does not exist")
-
-        return concat_n_df_1, concat_n_df_2
+                # Переделать n на коллекцию из БД
+        return concat_n_df

file_reader/file_reader.py

@@ -1,16 +1,22 @@
 import datetime
-import pandas as pd
-
+import pathlib
 
-# from pathlib import Path
+import pandas as pd
 
 
 class FileReader:
+    """Класс для чтения файлов ПРИЗМА-32, должен быть общим во всех модулях разработки"""
+
     __amp_n_cols = []
     for i in range(1, 17):
         __amp_n_cols.append(f'amp{i}')
         __amp_n_cols.append(f'n{i}')
 
+    __slots__ = ["cluster", "cluster_n", 'path_to_files', 'single_date']
+
+    # Для оптимизации вызова экземпляра класса, так как вызывается экземпляр на каждый день
+    # работы установки.
+
     def __init__(self, cluster, single_date, path_to_files=''):
         self.cluster = cluster
         if cluster == 1:
@@ -19,28 +25,26 @@ class FileReader:
             self.cluster_n = '2'
         self.path_to_files = path_to_files
         self.single_date = single_date
-        self.n_file_path = self.making_file_path(file_type='n')
-        self.n7_file_path = self.making_file_path(file_type='n7')
-        self.t_file_path = self.making_file_path(file_type='t')
-        self.p_file_path = self.making_file_path_eas_p(file_directory='nv', file_type='p')
-        self.eas_file_path = self.making_file_path_eas_p(file_directory='EAS', file_type='eas')
 
-    def __del__(self):
-        pass
+        # self.eas_file_path = self.making_file_path(file_directory='EAS', file_type='eas')
+        # Понадобится, когда добавим eas-файлы
 
-    def making_file_path(self, file_type):
-        file_path = f'{self.path_to_files}\\{file_type}\\{self.cluster_n}{file_type}_{self.single_date.month:02}-{self.single_date.day:02}.{self.single_date.year - 2000:02}'
-        return file_path
-
-    def making_file_path_eas_p(self, file_directory, file_type):
-        file_path = f'{self.path_to_files}/{file_directory}/{self.cluster}{file_type}_{self.single_date.month:02}-{self.single_date.day:02}.{self.single_date.year - 2000:02}'
+    def making_file_path(self, file_type, file_directory=None):
+        """Функция для построения путей для различных типов файлов ПРИЗМА-32"""
+        file_directory = file_type if file_directory is None else file_directory
+        file_name = self.cluster_n + \
+                    f'{file_type}_{self.single_date.month:02}-' + \
+                    f'{self.single_date.day:02}.{self.single_date.year - 2000:02}'
+        file_path = pathlib.PurePath(self.path_to_files, file_directory, file_name)
         return file_path
 
     def reading_n_file(self):
-        """Метод, прочитывающий n-файлы, возвращающий датафрейм дня на выходе. Или возвращающий filenotfounderror, если
-                файла нет"""
-        print(self.n_file_path)
-        n_file = pd.read_csv(self.n_file_path,
+        """Метод, прочитывающий n-файлы. Делит файл на два датафрейма, если в файле присутствуют
+         события следующего дня и возвращает их на выходе. Если в файле нет события следующего дня,
+         то возвращает один датафрейм и пустую строку"""
+        n_file_path = self.making_file_path(file_type='n')
+        print(n_file_path)
+        n_file = pd.read_csv(n_file_path,
                              sep=r'\s[-]*\s*', header=None, skipinitialspace=True, index_col=False, engine='python')
         n_file.dropna(axis=1, how='all', inplace=True)
         n_file.columns = ['time', 'number', 'sum_n', 'trigger'] + self.__class__.__amp_n_cols
@@ -54,16 +58,21 @@ class FileReader:
         return n_file, []
 
     def reading_n7_file(self):
-        print(self.n7_file_path)
+        """Метод, прочитывающий n7-файлы. При ошибке формата файла ValueError(надо указать какой, кстати) запускает
+        функцию конвертера n7-файлов. После успешного прочтения делит файл на два датафрейма, если в файле присутствуют
+        события следующего дня и возвращает их на выходе. Если в файле нет события следующего дня, то возвращает один
+        датафрейм и пустую строку"""
+        n7_file_path = self.making_file_path(file_type='n7')
+        print(n7_file_path)
         try:
-            n7_file = pd.read_csv(self.n7_file_path,
+            n7_file = pd.read_csv(n7_file_path,
                                   sep=r'\s[-]*\s*', header=None, skipinitialspace=True, index_col=False,
                                   engine='python')
             n7_file.dropna(axis=1, how='all', inplace=True)
             n7_file.columns = ['time', 'number', 'trigger'] + [f'amp{i}' for i in range(1, 17)]
-        except ValueError:
-            self.n7_file_conventer()
-            n7_file = pd.read_csv(self.n7_file_path,
+        except ValueError:  # указать, что за ValueError
+            self.n7_file_conventer(n7_file_path)
+            n7_file = pd.read_csv(n7_file_path,
                                   sep=r'\s[-]*\s*', header=None, skipinitialspace=True, index_col=False,
                                   engine='python')
             n7_file.dropna(axis=1, how='all', inplace=True)
@@ -77,52 +86,52 @@ class FileReader:
             n7_file_today = n7_file[n7_file.index < bad_end_time_index[0]]
             n7_file_day_after = n7_file[n7_file.index >= bad_end_time_index[0]]
             return n7_file_today, n7_file_day_after
-
         return n7_file, []
 
     @staticmethod
-    def concat_data(file_today, file_day_after, single_date, concat_n_df):
-        file_today['Date'] = [single_date.date()] * len(file_today.index)
-        concat_n_df = pd.concat([concat_n_df, file_today], ignore_index=True)
-        if any(file_day_after):
-            file_day_after['Date'] = [(single_date + datetime.timedelta(
-                days=1)).date()] * len(file_day_after.index)
-            concat_n_df = pd.concat([concat_n_df, file_day_after],
-                                    ignore_index=True)
-        return concat_n_df
+    def n7_file_conventer(n7_file_path):
+        """Статический метод конвентера для n7-файлов, если в них амплитуды записываются не на одной строчке с
+        событием"""
+        with open(n7_file_path, 'r', encoding='utf-8') as n7_file_read:
+            raw_data = n7_file_read.readlines()
+        if len(list(filter(lambda x: x != '', raw_data[0].rstrip().split(' ')))) < 5:
+            start_of_strings = [line.rstrip() for line in raw_data[::2]]
+            end_of_strings = raw_data[1::2]
+            raw_data = [x + ' ' + y for x, y in zip(start_of_strings, end_of_strings)]
+            with open(n7_file_path, 'w', encoding='utf-8') as n7_file_write:
+                n7_file_write.writelines(raw_data)
+        else:
+            raise FileNotFoundError
+
+    def t_file_conventer(self):
+        """Конвентер для t-файлов ПРИЗМА-32, возвращает датафрейм t-файла,
+         с которым сделать merge датафрейма n-файла"""
+        t_file_path = self.making_file_path(file_type='t')
 
-    def reading_t_file(self):
-        """Converter for PRISMA t-files"""
-        with open(self.t_file_path) as f:
-            raw_data = f.readlines()
-        raw_data = [line.rstrip() for line in raw_data]
-        # Убираем переводы строки
-        event_list = []
-        main_list = []
+        def reading_t_file(t_path):
+            """Генератор для чтения t-файлов"""
+            with open(t_path, encoding='utf-8') as file:
+                for file_line in file.readlines():
+                    yield file_line.rstrip()
+
+        raw_data = list(reading_t_file(t_path=t_file_path))
+        event_list, main_list = [], []
         sep = 0
-        for i in range(len(raw_data)):
+        for i, _ in enumerate(raw_data):
             if raw_data[i] == '*#*':
                 main_list.append(raw_data[sep].split(' '))
                 event_list.append(raw_data[sep + 1:i])
                 sep = i + 1
-        unit_delay = []
+        plural_data_list = []
         for item in event_list:
-            delay_per_event = []
+            time_list, detector_list, neut_quantity_list = [], [], []
             for line in item:
                 step = line.split(' ')
                 for i in range(1, 17):
                     if int(step[i]) != 0:
-                        delay_per_event.append([round(int(step[0]) * (10 ** (-4)), 4), i, int(step[i])])
-            unit_delay.append(delay_per_event)
-        plural_data_list = []
-        for i in unit_delay:
-            time_list = []
-            detector_list = []
-            neut_quantity_list = []
-            for j in i:
-                time_list.append(j[0])
-                detector_list.append(j[1])
-                neut_quantity_list.append(j[2])
+                        time_list.append(round(int(step[0]) * (10 ** (-4)), 4))
+                        detector_list.append(i)
+                        neut_quantity_list.append(int(step[i]))
             plural_data_list.append([time_list, detector_list, neut_quantity_list])
         for i in range(len(main_list)):
             main_list[i].extend(plural_data_list[i])
@@ -133,22 +142,10 @@ class FileReader:
         t_file_df = t_file_df[t_file_df["time"] < 86400]
         return t_file_df
 
-    def n7_file_conventer(self):
-        with open(self.n7_file_path, 'r') as f:
-            raw_data = f.readlines()
-        if len(list(filter(lambda x: x != '', raw_data[0].rstrip().split(' ')))) < 5:
-            start_of_strings = [line.rstrip() for line in raw_data[::2]]
-            end_of_strings = raw_data[1::2]
-            raw_data = [x + ' ' + y for x, y in zip(start_of_strings, end_of_strings)]
-            with open(self.n7_file_path, 'w') as f:
-                f.writelines(raw_data)
-        else:
-            raise FileNotFoundError
-
     def reading_p_file(self):
-        """Метод, прочитывающий p-файлы, возвращающий датафрейм дня на выходе. Или возвращающий filenotfounderror, если
-        файла нет"""
-        p_file = pd.read_csv(self.p_file_path,
+        """Метод, прочитывающий p-файлы, возвращающий датафрейм дня на выходе."""
+        p_file_path = self.making_file_path(file_directory='nv', file_type='p')
+        p_file = pd.read_csv(p_file_path,
                              sep=r'\s[-]*\s*', header=None, skipinitialspace=True, engine='python')
         p_file.dropna(axis=1, how='all', inplace=True)
         corr_p_file = self.correcting_p_file(p_file)
@@ -164,10 +161,10 @@ class FileReader:
         p_file = p_file.sort_values(by='time')
         if len(p_file['time']) > len(p_file['time'].unique()):
             p_file.drop_duplicates(keep=False, inplace=True)
-            """После удаления полных дубликатов ищем повторяющиеся индексы. Сначала удаляем строки, 
-            состоящие полностью из нулей и точек (value = len(p_file.columns)), потом ищем множество 
-            дубликатов индексов и множество строк, почти полностью (value > 30) состоящих из нулей и точек. 
-            Берем пересечение этих двух множеств и удаляем находящиеся в пересечении строки"""
+            # После удаления полных дубликатов ищем повторяющиеся индексы. Сначала удаляем строки,
+            # состоящие полностью из нулей и точек (value = len(p_file.columns)), потом ищем множество
+            # дубликатов индексов и множество строк, почти полностью (value > 30) состоящих из нулей и точек.
+            # Берем пересечение этих двух множеств и удаляем находящиеся в пересечении строки
             null_row = dict(p_file.isin([0, '.']).sum(axis=1))  # Проверяем на нули и точки
             all_null_index = list(
                 {key: value for key, value in null_row.items() if value == len(p_file.columns)}.keys())
@@ -179,8 +176,37 @@ class FileReader:
             same_index_row = list({key: value for key, value in same_index.items() if value is True}.keys())
             bad_index = list(set(null_index) & set(same_index_row))
             p_file.drop(index=bad_index, inplace=True)
-            """Также может быть, что после фильтрации осталось больше строк, чем нужно, так как в старых 
-            p-файлах может быть больше индексов, чем минут в дне. Тогда оставляем только 288"""
+            # Также может быть, что после фильтрации осталось больше строк, чем нужно, так как в старых
+            # p-файлах может быть больше индексов, чем минут в дне. Тогда оставляем только 288
             if len(p_file.index) == 289:
                 p_file = p_file.head(288)
         return p_file
+
+    @staticmethod
+    def concat_data(file_today, file_day_after, single_date, concat_n_df):
+        """Статический метод соединения датафреймов файлов, полученных на выходе в один с добавления колонки с датой"""
+        file_today['Date'] = [single_date.date()] * len(file_today.index)
+        concat_n_df = pd.concat([concat_n_df, file_today], ignore_index=True)
+        if any(file_day_after):  # не пропускает пустую строку
+            file_day_after['Date'] = [(single_date + datetime.timedelta(
+                days=1)).date()] * len(file_day_after.index)
+            concat_n_df = pd.concat([concat_n_df, file_day_after], ignore_index=True)
+        return concat_n_df
+
+    @staticmethod
+    def preparing_data(start_date, end_date, cluster, path_to_files):
+        """Статический метод подготовки данных из n-файлов за определенный период для определенного кластера"""
+        concat_n_df = pd.DataFrame(columns=['Date', 'time', 'trigger'] + FileReader.__amp_n_cols)
+        for single_date in pd.date_range(start_date - datetime.timedelta(days=1), end_date):
+            # минус один день в timedelta, так как начальные события первого дня могут остаться в n-файле предыдущего
+            # дня
+            try:
+                n_file_reader = FileReader(cluster=cluster, single_date=single_date, path_to_files=path_to_files)
+                n_file_today, n_file_day_after = n_file_reader.reading_n_file()
+                concat_n_df = n_file_reader.concat_data(file_today=n_file_today, file_day_after=n_file_day_after,
+                                                        concat_n_df=concat_n_df, single_date=single_date)
+            except FileNotFoundError:
+                print(
+                    f"File {path_to_files}/n_{single_date.month:02}-" +
+                    f"{single_date.day:02}.{single_date.year - 2000:02}', does not exist")
+        return concat_n_df

noSQL_db_Prisma.py

@@ -1,33 +1,32 @@
 import datetime
-
+import pathlib
 import pymongo
 
-from config_info.config import *
+import config_info.config
 from file_reader.file_reader import FileReader
 
 
-# from pathlib import Path
-
-
 # noinspection DuplicatedCode
 class NoSQLPrisma:
-    __DB_URL = DB_URL
+    """Класс записи n, n7, t - файлов в MongoDB базу данных PRISMA-32"""
+    __DB_URL = config_info.config.DB_URL
     __db_client = pymongo.MongoClient(__DB_URL)
     __prisma_db = __db_client["prisma-32_db"]
+    __slots__ = ["cluster", "single_date", "file_reader"]
 
     def __init__(self, cluster, single_date):
         self.cluster = cluster
         self.single_date = single_date
         self.file_reader = FileReader(cluster=self.cluster, single_date=self.single_date,
-                                      path_to_files=f'D:\\PRISMA20\\P{self.cluster}')
-
-    # def __del__(self):
-    #     pass
+                                      path_to_files=pathlib.PurePath('D:\\PRISMA20', f'P{self.cluster}'))
 
     def dinods_data_copier(self, event_datetime, trigger, det_params, dinode):
+        """Метод, создающий запись в базе данных, пользуясь информацией из его аргументов,
+        если запись в БД уже есть, то кидает ошибку"""
         try:
             new_record = {
-                '_id': f'{event_datetime.date()}_{self.cluster:02}_{dinode:02}d_{int(event_datetime.hour):02}:' +
+                '_id': f'{event_datetime.date()}_{self.cluster:02}_{dinode:02}d' +
+                       f'_{int(event_datetime.hour):02}:' +
                        f'{int(event_datetime.minute):02}:{int(event_datetime.second):02}.' +
                        f'{str(event_datetime.microsecond)[:3]}.000.000',
                 'time_ns': int((int(event_datetime.hour) * 3600 + int(event_datetime.minute) * 60 + int(
@@ -39,23 +38,32 @@ class NoSQLPrisma:
             collection_prisma = NoSQLPrisma.__prisma_db[f'{str(event_datetime.date())}_{dinode}d']
             ins_result = collection_prisma.insert_one(new_record)
             print(f'Copied - {ins_result.inserted_id}')
+            # with open('log.txt', 'a+') as log_file:
+            #     log_file.write(f'Copied - {ins_result.inserted_id}\n')
         except pymongo.errors.DuplicateKeyError:
-            print(f'Ошибка - {event_datetime.date()}-{event_datetime.time()}')
+            print(f'Запись существует - {self.cluster}cl - {dinode:02}d' +
+                  f' - {event_datetime.date()}-{event_datetime.time()}')
+            # with open('log.txt', 'a+') as log_file:
+            #     log_file.write(f'Ошибка - {event_datetime.date()}-{event_datetime.time()}\n')
 
     def prisma_12d_past_data_copier(self):
-        n_file_today, n_file_day_after = self.file_reader.reading_n_file()
+        """Главный метод для данных 12-динода, в котором происходит чтение n
+        и t-файлов и их соединение, определение их параметров и запись в БД"""
+        n_file_today, n_file_day_after = self.file_reader.reading_n_file()  # Если n-файла, нет то
+        # проброс исключение идет в runner.py
         try:
-            t_file = self.file_reader.reading_t_file()
-            n_file_today = n_file_today.merge(t_file)
+            t_file = self.file_reader.t_file_conventer()
+            n_file_today = n_file_today.merge(t_file)  # А что делать, если не все строки в t-файле совпадают
             self.make_params_from_df_12_d(n_file_today, self.single_date)
             if any(n_file_day_after):
                 n_file_day_after = n_file_day_after.merge(t_file)
                 self.make_params_from_df_12_d(n_file_day_after,
                                               self.single_date + datetime.timedelta(
                                                   days=1))
+        # Идет проброс исключение на существование t-файла и вызывается метод make_params_from_df_12_d_no_t
         except FileNotFoundError:
-            with open(f't_{self.cluster}cl_files_not_found.txt', 'a+') as f:
-                f.write(f't-файла {self.cluster}-го кластера от {self.single_date} не существует\n')
+            with open(f't_{self.cluster}cl_files_not_found.txt', 'a+', encoding='utf-8') as t_log_file:
+                t_log_file.write(f't-файла {self.cluster}-го кластера от {self.single_date} не существует\n')
             self.make_params_from_df_12_d_no_t(n_file_today, self.single_date)
             if any(n_file_day_after):
                 self.make_params_from_df_12_d_no_t(n_file_day_after,
@@ -63,6 +71,8 @@ class NoSQLPrisma:
                                                        days=1))
 
     def prisma_7d_past_data_copier(self):
+        """Главный метод для данных 7-динода, в котором происходит чтение n7,
+                определение их параметров и запись в БД"""
         n7_file_today, n7_file_day_after = self.file_reader.reading_n7_file()
         self.make_params_from_df_7_d(n7_file_today, self.single_date)
         if any(n7_file_day_after):
@@ -70,15 +80,20 @@ class NoSQLPrisma:
                                          self.single_date + datetime.timedelta(days=1))
 
     def make_params_from_df_12_d(self, df, date):
+        """Метод для данных 12-динода, парсящий построчно n+t-dataframe, определяющий все нужные для БД
+        параметры события: время регистрации, амплитуды и кол-во нейтронов по детекторно, триггер,
+        время запаздывания нейтронов."""
         for index in range(len(df.index)):
             params = list(df.iloc[index])
             event_time = str(datetime.timedelta(seconds=params[0]))
+            event_time_split = event_time.split(':')
             event_datetime = datetime.datetime(date.year, date.month, date.day,
-                                               int(event_time.split(':')[0]),
-                                               int(event_time.split(':')[1]), int(float(event_time.split(':')[2])),
+                                               int(event_time_split[0]),
+                                               int(event_time_split[1]),
+                                               int(float(event_time_split[2])),
                                                int(round(
-                                                   float(event_time.split(':')[2]) - int(
-                                                       float(event_time.split(':')[2])),
+                                                   float(event_time_split[2]) - int(
+                                                       float(event_time_split[2])),
                                                    2) * 10 ** 6)) - datetime.timedelta(hours=4)
             trigger = params[3]
             amp = [int(params[j]) for j in range(4, 36, 2)]
@@ -100,20 +115,24 @@ class NoSQLPrisma:
                     'neutrons': n[i - 1],
                     'time_delay': n_time_delay_by_det
                 }
+            # Вызывает в конце dinods_data_copier для записи в БД всю информацию о событии
             self.dinods_data_copier(event_datetime=event_datetime, trigger=trigger,
                                     det_params=det_params, dinode=12)
-        return None
 
     def make_params_from_df_7_d(self, df, date):
+        """Метод для данных 7-динода, парсящий построчно n7-dataframe, определяющий все нужные для БД
+                параметры события: время регистрации, амплитуды по детекторно, триггер"""
         for index in range(len(df.index)):
             params = list(df.iloc[index])
             event_time = str(datetime.timedelta(seconds=params[0]))  # перевод в utc-формат
+            event_time_split = event_time.split(':')
             event_datetime = datetime.datetime(date.year, date.month, date.day,
-                                               int(event_time.split(':')[0]),
-                                               int(event_time.split(':')[1]), int(float(event_time.split(':')[2])),
+                                               int(event_time_split[0]),
+                                               int(event_time_split[1]),
+                                               int(float(event_time_split[2])),
                                                int(round(
-                                                   float(event_time.split(':')[2]) - int(
-                                                       float(event_time.split(':')[2])),
+                                                   float(event_time_split[2]) - int(
+                                                       float(event_time_split[2])),
                                                    2) * 10 ** 6)) - datetime.timedelta(hours=4)
             trigger = params[2]
             amp = [int(params[j]) for j in range(3, 19)]
@@ -124,20 +143,25 @@ class NoSQLPrisma:
                 det_params[f'det_{i:02}'] = {
                     'amplitude': amp[i - 1]
                 }
+            # Вызывает в конце dinods_data_copier для записи в БД всю информацию о событии
             self.dinods_data_copier(event_datetime=event_datetime, trigger=trigger,
                                     det_params=det_params, dinode=7)
-        return None
 
     def make_params_from_df_12_d_no_t(self, df, date):
+        """Метод для данных 12-динода, парсящий построчно n-dataframe, так t-файла не существует в эту дату,
+           определяющий все нужные для БД параметры события: время регистрации,
+           амплитуды и кол-во нейтронов по детекторно, триггер."""
         for index in range(len(df.index)):
             params = list(df.iloc[index])
             event_time = str(datetime.timedelta(seconds=params[0]))
+            event_time_split = event_time.split(':')
             event_datetime = datetime.datetime(date.year, date.month, date.day,
-                                               int(event_time.split(':')[0]),
-                                               int(event_time.split(':')[1]), int(float(event_time.split(':')[2])),
+                                               int(event_time_split[0]),
+                                               int(event_time_split[1]),
+                                               int(float(event_time_split[2])),
                                                int(round(
-                                                   float(event_time.split(':')[2]) - int(
-                                                       float(event_time.split(':')[2])),
+                                                   float(event_time_split[2]) - int(
+                                                       float(event_time_split[2])),
                                                    2) * 10 ** 6)) - datetime.timedelta(hours=4)
             trigger = params[3]
             amp = [int(params[j]) for j in range(4, 36, 2)]
@@ -151,6 +175,6 @@ class NoSQLPrisma:
                     'neutrons': n[i - 1],
                     'time_delay': False
                 }
+            # Вызывает в конце dinods_data_copier для записи в БД всю информацию о событии
             self.dinods_data_copier(event_datetime=event_datetime, trigger=trigger,
                                     det_params=det_params, dinode=12)
-        return None

prisma_12d_db_copier.py

@@ -1,146 +0,0 @@
-import datetime
-
-import pandas as pd
-import pymongo
-
-from config_info.config import *
-
-db_client = pymongo.MongoClient(DB_URL)
-prisma_db = db_client["prisma-32_db"]
-
-
-def t_file_converter(path, cluster, date_):
-    """Converter for PRISMA t-files"""
-    with open(f'{path}{cluster}t_{date_.month:02}-{date_.day:02}.{date_.year - 2000:02}') as f:
-        raw_data = f.readlines()
-    raw_data = [line.rstrip() for line in raw_data]
-    # Убираем переводы строки
-    event_list = []
-    main_list = []
-    sep = 0
-    for i in range(len(raw_data)):
-        if raw_data[i] == '*#*':
-            main_list.append(raw_data[sep].split(' '))
-            event_list.append(raw_data[sep + 1:i])
-            sep = i + 1
-    unit_delay = []
-    for item in event_list:
-        delay_per_event = []
-        for line in item:
-            step = line.split(' ')
-            for i in range(1, 17):
-                if int(step[i]) != 0:
-                    delay_per_event.append([round(int(step[0]) * (10 ** (-4)), 4), i, int(step[i])])
-        unit_delay.append(delay_per_event)
-    plural_data_list = []
-    for i in unit_delay:
-        time_list = []
-        detector_list = []
-        neut_quantity_list = []
-        for j in i:
-            time_list.append(j[0])
-            detector_list.append(j[1])
-            neut_quantity_list.append(j[2])
-        plural_data_list.append([time_list, detector_list, neut_quantity_list])
-    for i in range(len(main_list)):
-        main_list[i].extend(plural_data_list[i])
-    t_file_df = pd.DataFrame(main_list,
-                             columns=['time', 'number', 'sum_n', 'trigger', 'time_delay', 'detectors', 'n_per_step'])
-    t_file_df = t_file_df.astype({"time": float, "number": int, "sum_n": int, "trigger": int})
-    return t_file_df
-
-
-def prisma_12d_past_data_copier(date, cluster):
-    if cluster == 1:
-        n_file_template = f"n_{date.month:02}-{date.day:02}.{date.year - 2000:02}"
-        n_file = pd.read_csv(PATH_TO_PRISMA_1_DATA + n_file_template, sep=' ', skipinitialspace=True, header=None)
-        n_file = n_file.dropna(axis=1, how='all')
-        n_file.columns = ['time', 'number', 'sum_n', 'trigger'] + list(range(32))
-        print("Data file: {}".format(PATH_TO_PRISMA_1_DATA + n_file_template))
-        t_file = t_file_converter(PATH_TO_PRISMA_1_T_FILES, "", date)
-        n_file = n_file.merge(t_file)
-        fix_end_time_series = n_file['time'].lt(n_file['time'].shift())
-        bad_end_time_index = fix_end_time_series[fix_end_time_series == True].index
-    else:
-        n_file_template = f"2n_{date.month:02}-{date.day:02}.{date.year - 2000:02}"
-        n_file = pd.read_csv(PATH_TO_PRISMA_2_DATA + n_file_template, sep=' ', skipinitialspace=True, header=None)
-        n_file = n_file.dropna(axis=1, how='all')
-        n_file.columns = ['time', 'number', 'sum_n', 'trigger'] + list(range(32))
-        print("Data file: {}".format(PATH_TO_PRISMA_2_DATA + n_file_template))
-        t_file = t_file_converter(PATH_TO_PRISMA_2_T_FILES, 2, date)
-        n_file = n_file.merge(t_file)
-        fix_end_time_series = n_file['time'].lt(n_file['time'].shift())
-        bad_end_time_index = fix_end_time_series[fix_end_time_series == True].index
-    for index in range(len(n_file.index)):
-        params = list(n_file.iloc[index])
-        event_time = str(datetime.timedelta(seconds=params[0]))
-        # event_date = (datetime.timedelta(seconds=params[0]) + datetime.timedelta(hours=3)).date()
-        event_datetime = datetime.datetime(date.year, date.month, date.day, int(event_time.split(':')[0]),
-                                           int(event_time.split(':')[1]), int(float(event_time.split(':')[2])),
-                                           int(round(
-                                               float(event_time.split(':')[2]) - int(float(event_time.split(':')[2])),
-                                               2) * 10 ** 6)) - datetime.timedelta(hours=4)
-        if index >= bad_end_time_index:
-            new_date = date + datetime.timedelta(days=1)
-            event_datetime = datetime.datetime(new_date.year, new_date.month, new_date.day, int(event_time.split(':')[0]),
-                                           int(event_time.split(':')[1]), int(float(event_time.split(':')[2])),
-                                           int(round(
-                                               float(event_time.split(':')[2]) - int(float(event_time.split(':')[2])),
-                                               2) * 10 ** 6)) - datetime.timedelta(hours=4)
-        trigger = params[3]
-        amp = [int(params[j]) for j in range(4, 36, 2)]
-        n = [int(params[j]) for j in range(5, 37, 2)]
-
-        n_time_delay = params[36]
-        detector = params[37]
-        n_in_step = params[38]
-
-        det_params = {}
-        for i in range(1, 17):
-            n_time_delay_by_det = []
-            detector_index = [ind for ind, v in enumerate(detector) if v == i]
-            for j in detector_index:
-                n_time_delay_by_det.extend([n_time_delay[j]] * int(n_in_step[j]))
-            #  В БД будут оставаться пустые списки при нуле нейтронов, надо ли это фиксить?
-            det_params[f'det_{i:02}'] = {
-                'amplitude': amp[i - 1],
-                'neutrons': n[i - 1],
-                'time_delay': n_time_delay_by_det
-            }
-
-        try:
-            new_record = {
-                '_id': f'{event_datetime.date()}_{cluster:02}_12d_{int(event_datetime.hour):02}:' +
-                       f'{int(event_datetime.minute):02}:{int(event_datetime.second):02}.' +
-                       f'{str(event_datetime.microsecond)[:3]}.000.000',
-                'time_ns': int((int(event_datetime.hour) * 1440 + int(event_datetime.minute) * 60 + int(
-                    event_datetime.second)) * 10e8 + int(event_datetime.microsecond) * 1000),
-                'cluster': cluster,
-                'trigger': int(trigger),
-                'detectors': det_params
-            }
-            collection_prisma = prisma_db[f'{str(event_datetime.date())}_12d']
-            ins_result = collection_prisma.insert_one(new_record)
-            print(f'Copied - {ins_result.inserted_id}')
-        except pymongo.errors.DuplicateKeyError:
-            print(f'Ошибка - {event_datetime.date()}-{event_time}')
-
-
-# Press the green button in the gutter to run the script.
-if __name__ == '__main__':
-    cluster_1 = 1
-    cluster_2 = 2
-    date_time_start = datetime.date(2021, 12, 1)  # посмотреть почему не собирается конец дня 2018-04-22
-    date_time_stop = datetime.date(2021, 12, 1)
-    LIST_OF_DATES = [(date_time_start + datetime.timedelta(days=i)) for i in
-                     range((date_time_stop - date_time_start).days + 1)]
-    for date in LIST_OF_DATES:
-        try:
-            prisma_12d_past_data_copier(date, cluster_1)
-        except FileNotFoundError:
-            print(f'файла {cluster_1}-го кластера от {date} не существует')
-        try:
-            prisma_12d_past_data_copier(date, cluster_2)
-        except FileNotFoundError:
-            print(f'файла {cluster_2}-го кластера от {date} не существует')
-    print('test')

prisma_7d_db_copier.py

@@ -1,98 +0,0 @@
-import datetime
-
-import pandas as pd
-import pymongo
-
-from config_info.config import *
-
-db_client = pymongo.MongoClient(DB_URL)
-prisma_db = db_client["prisma-32_db"]
-
-
-def prisma_7d_past_data_copier(date, cluster):
-    if cluster == 1:
-        n7_file_template = f"n7_{date.month:02}-{date.day:02}.{date.year - 2000:02}"
-        n7_file = pd.read_csv(PATH_TO_PRISMA_1_7d_DATA + n7_file_template, sep=' ', skipinitialspace=True, header=None)
-        n7_file = n7_file.dropna(axis=1, how='all')
-        for i in range(len(n7_file[0])):
-            if type(n7_file[0][i]) is str:
-                n7_file.loc[i,0] = float('.'.join(n7_file.loc[i,0].split(',')))
-        print("Data file: {}".format(PATH_TO_PRISMA_1_7d_DATA + n7_file_template))
-        fix_end_time_series = n7_file[0].lt(n7_file[0].shift())
-        bad_end_time_index = fix_end_time_series[fix_end_time_series == True].index
-    else:
-        n7_file_template = f"2n7_{date.month:02}-{date.day:02}.{date.year - 2000:02}"
-        n7_file = pd.read_csv(PATH_TO_PRISMA_2_7d_DATA + n7_file_template, sep=' ', skipinitialspace=True, header=None)
-        n7_file = n7_file.dropna(axis=1, how='all')
-        for i in range(len(n7_file[0])):
-            if type(n7_file[0][i]) is str:
-                n7_file.loc[i,0] = float('.'.join(n7_file.loc[i,0].split(',')))
-        print("Data file: {}".format(PATH_TO_PRISMA_2_7d_DATA + n7_file_template))
-        fix_end_time_series = n7_file[0].lt(n7_file[0].shift())
-        bad_end_time_index = fix_end_time_series[fix_end_time_series == True].index
-    for index in range(len(n7_file.index)):
-        params = list(n7_file.iloc[index])
-        # if type(params[0]) is str:
-        #     params[0] = float('.'.join(params[0].split(',')))
-        event_time = str(datetime.timedelta(seconds=params[0]))  # перевод в utc-формат
-        # event_date = (datetime.timedelta(seconds=params[0]) + datetime.timedelta(hours=3)).date()
-        event_datetime = datetime.datetime(date.year, date.month, date.day, int(event_time.split(':')[0]),
-                                           int(event_time.split(':')[1]), int(float(event_time.split(':')[2])),
-                                           int(round(
-                                               float(event_time.split(':')[2]) - int(float(event_time.split(':')[2])),
-                                               2) * 10 ** 6)) - datetime.timedelta(hours=4)
-        if index >= bad_end_time_index:
-            new_date = date + datetime.timedelta(days=1)
-            event_datetime = datetime.datetime(new_date.year, new_date.month, new_date.day,
-                                               int(event_time.split(':')[0]),
-                                               int(event_time.split(':')[1]), int(float(event_time.split(':')[2])),
-                                               int(round(
-                                                   float(event_time.split(':')[2]) - int(
-                                                       float(event_time.split(':')[2])),
-                                                   2) * 10 ** 6)) - datetime.timedelta(hours=4)
-        trigger = params[2]
-        amp = [int(params[j]) for j in range(3, 19)]
-
-        det_params = {}
-
-        for i in range(1, 17):
-            det_params[f'det_{i:02}'] = {
-                'amplitude': amp[i - 1]
-            }
-
-        try:
-            new_record = {
-                '_id': f'{event_datetime.date()}_{cluster:02}_07d_{int(event_datetime.hour):02}:' +
-                       f'{int(event_datetime.minute):02}:{int(event_datetime.second):02}.' +
-                       f'{str(event_datetime.microsecond)[:3]}.000.000',
-                'time_ns': int((int(event_datetime.hour) * 1440 + int(event_datetime.minute) * 60 + int(
-                    event_datetime.second)) * 10e8 + int(event_datetime.microsecond) * 1000),
-                'cluster': cluster,
-                'trigger': int(trigger),
-                'detectors': det_params
-            }
-            collection_prisma = prisma_db[f'{str(event_datetime.date())}_7d']
-            ins_result = collection_prisma.insert_one(new_record)
-            print(f'Copied - {ins_result.inserted_id}')
-        except pymongo.errors.DuplicateKeyError:
-            print(f'Ошибка - {event_datetime.date()}-{event_time}')
-
-
-# Press the green button in the gutter to run the script.
-if __name__ == '__main__':
-    cluster_1 = 1
-    cluster_2 = 2
-    date_time_start = datetime.date(2021, 12, 1)  # посмотреть почему не собирается конец дня 2018-04-22
-    date_time_stop = datetime.date(2021, 12, 31)
-    LIST_OF_DATES = [(date_time_start + datetime.timedelta(days=i)) for i in
-                     range((date_time_stop - date_time_start).days + 1)]
-    for date in LIST_OF_DATES:
-        try:
-            prisma_7d_past_data_copier(date, cluster_1)
-        except FileNotFoundError:
-            print(f'файла {cluster_1}-го кластера от {date} не существует')
-        try:
-            prisma_7d_past_data_copier(date, cluster_2)
-        except FileNotFoundError:
-            print(f'файла {cluster_2}-го кластера от {date} не существует')
-    print('test')

runner.py

@@ -1,9 +1,9 @@
 import datetime
-from noSQL_db_Prisma import NoSQLPrisma
+from nosql_db_prisma import NoSQLPrisma
 
 
 date_time_start = datetime.date(2020, 11, 11)  # посмотреть почему не собирается конец дня 2018-04-22
-date_time_stop = datetime.date(2021, 12, 31)
+date_time_stop = datetime.date(2020, 11, 12)
 # date_time_stop = datetime.date.today()
 LIST_OF_DATES = [(date_time_start + datetime.timedelta(days=i)) for i in
                  range((date_time_stop - date_time_start).days + 1)]
@@ -11,23 +11,22 @@ for date in LIST_OF_DATES:
     try:
         NoSQLPrisma(cluster=1, single_date=date).prisma_12d_past_data_copier()
     except FileNotFoundError:
-        print('нет')
-        with open('n_1cl_files_not_found.txt', 'a+') as f:
+        with open('n_1cl_files_not_found.txt', 'a+', encoding='utf-8') as f:
             f.write(f'n-файла 1-го кластера от {date} не существует\n')
     try:
         NoSQLPrisma(cluster=2, single_date=date).prisma_12d_past_data_copier()
     except FileNotFoundError:
 
-        with open('n_2cl_files_not_found.txt', 'a+') as f:
+        with open('n_2cl_files_not_found.txt', 'a+', encoding='utf-8') as f:
             f.write(f'n-файла 2-го кластера от {date} не существует\n')
     try:
         NoSQLPrisma(cluster=1, single_date=date).prisma_7d_past_data_copier()
     except FileNotFoundError:
-        with open('n7_1cl_files_not_found.txt', 'a+') as f:
+        with open('n7_1cl_files_not_found.txt', 'a+', encoding='utf-8') as f:
             f.write(f'n7-файла 1-го кластера от {date} не существует\n')
     try:
         NoSQLPrisma(cluster=2, single_date=date).prisma_7d_past_data_copier()
     except FileNotFoundError:
-        with open('n7_2cl_files_not_found.txt', 'a+') as f:
+        with open('n7_2cl_files_not_found.txt', 'a+', encoding='utf-8') as f:
             f.write(f'n7-файла 2-го кластера от {date} не существует\n')
 print('test')