educommon 3.12.0__py3-none-any.whl → 3.13.2__py3-none-any.whl

educommon/importer/XLSReader.py

@@ -30,10 +30,12 @@ _SPECIAL_KEYS = (
 
 
 def _fold(tree, path='', group=None):
-    """
+    """Свертка словаря-дерева.
+
     Свертка словаря-дерева в список пар (путь, значение, группа|None)
-    ("группа", это uuid, для группировки значений одного поддерева)
+    ("группа", это uuid, для группировки значений одного поддерева).
     """
+
     if not isinstance(tree, dict):
         return [(path, tree, group)]
 
@@ -41,20 +43,21 @@ def _fold(tree, path='', group=None):
         if tree.get(SUBTREE_CAN_BE_EMPTY, False):
             group = uuid.uuid4()
 
-    path = ('%s/%%s' % path) if path else '%s'
+    path = f'{path}/{{0}}' if path else '{0}'
+
     res = []
     for key, val in tree.items():
         if key in _SPECIAL_KEYS:
             continue
-        key = path % key
+
+        key = path.format(key)
         res.extend(_fold(val, key, group))
+
     return res
 
 
 def _unfold(lst):
-    """
-    Развертка списка пар (путь, значение) в словарь-дерево
-    """
+    """Развертка списка пар (путь, значение) в словарь-дерево."""
     res = {}
 
     def set_val(res, path, val):
@@ -79,9 +82,7 @@ MATCH_IF_CONTAINS = 3
 
 
 def _is_match(value, pattern, match_type=MATCH_IF_EXACT):
-    """
-    Проверка на совпадение значения с образцом
-    """
+    """Проверка на совпадение значения с образцом."""
     pattern = pattern.upper()
     value = value.upper()
 
@@ -89,29 +90,25 @@ def _is_match(value, pattern, match_type=MATCH_IF_EXACT):
         return value.find(pattern) >= 0
     elif match_type == MATCH_IF_STARTS_WITH:
         return value.startswith(pattern)
+
     return value == pattern
 
 
 class CellValueError(Exception):
-    """
-    Исключение для неверного значения ячейки
-    """
+    """Исключение для неверного значения ячейки."""
+
     pass
 
 
 class EmptyObligatoryCellError(CellValueError):
-    """
-    Исключение для неверного значения ячейки
-    """
+    """Исключение для неверного значения ячейки."""
+
     def __init__(self, message=None):
-        super(EmptyObligatoryCellError, self).__init__(
-            message or 'Ячейка не может быть пустой!')
+        super().__init__(message or 'Ячейка не может быть пустой!')
 
 
 class BaseCell:
-    """
-    Прототип парсера ячейки
-    """
+    """Прототип парсера ячейки."""
 
     _default = _NO_DEFAULT
 
@@ -125,15 +122,11 @@ class BaseCell:
         return (value, False)
 
     def _parse(self, value):
-        """
-        Разбор значения
-        """
+        """Разбор значения."""
         raise NotImplementedError('Прототип не используется напрямую!')
 
     def from_cell(self, sheet, row, col):
-        """
-        Получение значения из ячейки в виде (значение, is_default)
-        """
+        """Получение значения из ячейки в виде (значение, is_default)."""
         try:
             value = sheet.cell(row, col).value
         except IndexError:
@@ -144,7 +137,7 @@ class BaseCell:
         if isinstance(value, str):
             value = value.strip()
 
-        if value is None or value == "":
+        if value is None or value == '':
             if self.is_obligatory():
                 raise EmptyObligatoryCellError()
             return self.default()
@@ -156,19 +149,15 @@ class BaseCell:
 
 
 class StringCell(BaseCell):
-    """
-    Строковая ячейка
-    """
+    """Строковая ячейка."""
 
-    MSG_RECORD_TRUNCATED = (
-        'Превышена максимально допустимая длина записи. Запись сокращена'
-    )
+    MSG_RECORD_TRUNCATED = 'Превышена максимально допустимая длина записи. Запись сокращена'
 
     DEFAULT_RE_MESSAGE = 'Неправильный формат записи'
 
     def __init__(
-            self, default=_NO_DEFAULT, max_length=None, regex=None,
-            validator=None, error_message=None, verbose=True):
+        self, default=_NO_DEFAULT, max_length=None, regex=None, validator=None, error_message=None, verbose=True
+    ):
         """Строковая ячейка.
 
         :param int max_length: Максимальная длина строки.
@@ -179,7 +168,7 @@ class StringCell(BaseCell):
         """
         assert max_length is None or isinstance(max_length, int)
 
-        super(StringCell, self).__init__(default)
+        super().__init__(default)
 
         self._max_length = max_length
         self._verbose = verbose
@@ -218,9 +207,7 @@ class StringCell(BaseCell):
             except ValidationError as err:
                 if self._default is None:
                     if self._verbose:
-                        self.set_mgs(
-                            ', '.join(err.messages)
-                        )
+                        self.set_mgs(', '.join(err.messages))
                     value = ''
 
                 elif self._default is _NO_DEFAULT:
@@ -230,13 +217,13 @@ class StringCell(BaseCell):
 
     def _truncate(self, value):
         """Обрезает строку до указанной в self._max_length длины."""
-        new_value = value[:self._max_length]
+        new_value = value[: self._max_length]
         if self._verbose and new_value != value:
             self.set_mgs(self.MSG_RECORD_TRUNCATED)
+
         return new_value
 
     def _parse(self, value):
-
         self.message = None
 
         if value.endswith('.0'):
@@ -255,12 +242,9 @@ class StringCell(BaseCell):
 
 
 class MaybeStringCell(StringCell):
-    """
-    Строка или None
-    """
-    def __init__(
-            self, default=None, max_length=None, regex=None,
-            validator=None, error_message=None, verbose=True):
+    """Строка или None."""
+
+    def __init__(self, default=None, max_length=None, regex=None, validator=None, error_message=None, verbose=True):
         """Строка или None.
 
         :param int max_length: Максимальная длина строки.
@@ -269,33 +253,36 @@ class MaybeStringCell(StringCell):
         :param error_message: Сообщение в случае провала проверки.
         :param bool verbose: Записывать ли сообщения в лог.
         """
-        super(MaybeStringCell, self).__init__(
-            default=None, max_length=max_length, regex=regex,
-            validator=validator, error_message=error_message, verbose=verbose)
+        super().__init__(
+            default=None,
+            max_length=max_length,
+            regex=regex,
+            validator=validator,
+            error_message=error_message,
+            verbose=verbose,
+        )
 
 
 class RawCell(BaseCell):
+    """Сырая строковая ячейка "как есть".
+
+    В том числе с добавками Excel в зависимости от типа ячейки.
     """
-    Сырая строковая ячейка "как есть",
-    в том числе с добавками Excel в зависимости
-    от типа ячейки
-    """
+
     def _parse(self, value):
         return self.result(str(value))
 
 
 class MaybeRawCell(RawCell):
-    """
-    Сырая строковая ячейка "как есть" или None
-    """
+    """Сырая строковая ячейка "как есть" или None."""
+
     def __init__(self):
-        super(MaybeRawCell, self).__init__(default=None)
+        super().__init__(default=None)
 
 
 class IntCell(BaseCell):
-    """
-    Integer ячейка
-    """
+    """Integer ячейка."""
+
     def _parse(self, value):
         try:
             result = int(value)
@@ -303,73 +290,62 @@ class IntCell(BaseCell):
             try:
                 result = int(float(value))
             except (TypeError, ValueError):
-                raise CellValueError(
-                    'Число имеет неверный формат! "%s"' % value)
+                raise CellValueError(f'Число имеет неверный формат! "{value}"')
         return self.result(result)
 
 
 class MaybeIntCell(IntCell):
-    """
-    Int или None
-    """
+    """Int или None."""
+
     def __init__(self):
-        super(MaybeIntCell, self).__init__(default=None)
+        super().__init__(default=None)
 
 
 class MaybeNonNegativeIntCell(MaybeIntCell):
+    """Не отрицательное целое число или None.
+
+    Не отбрасывает дробную часть (если она больше 0) и райзит ошибку.
     """
-    Не отрицательное целое число или None
-    Не отбрасывает дробную часть (если она больше 0) и райзит ошибку
-    """
+
     def _parse(self, value):
-        result, _ = super(MaybeIntCell, self)._parse(value)
+        result, _ = super()._parse(value)
+
         if result < 0:
-            raise CellValueError(
-                'Число должно быть не меньше нуля! "%s"' % value)
+            raise CellValueError(f'Число должно быть не меньше нуля! "{value}"')
         if float(value) != float(int(float(value))):
-            raise CellValueError(
-                'Число должно быть целым! "%s"' % value)
+            raise CellValueError(f'Число должно быть целым! "{value}"')
         return self.result(result)
 
 
 class BooleanCell(BaseCell):
-    """
-    Bool-ячейка, получает True при совпадении с паттерном
-    """
-    def __init__(self, default=_NO_DEFAULT,
-                 pattern=None, match_type=MATCH_IF_EXACT):
-        """
-        Если паттерн опущен (или None), то результат будет True при любой
-        значащей строке в ячейке.
-        """
+    """Bool-ячейка, получает True при совпадении с паттерном."""
+
+    def __init__(self, default=_NO_DEFAULT, pattern=None, match_type=MATCH_IF_EXACT):
+        """Если паттерн опущен (или None), то результат будет True при любой значащей строке в ячейке."""
+        super().__init__(default=default)
 
-        super(BooleanCell, self).__init__(default=default)
         self.pattern = pattern
         self.match_type = match_type
 
     def _parse(self, value):
         if self.pattern is None:
-            return self.result(
-                bool(value.strip()))
+            return self.result(bool(value.strip()))
         return self.result(_is_match(value, self.pattern, self.match_type))
 
 
 class MaybeTrueCell(BooleanCell):
-    """
-    Bool-ячейка, которая получает значение True при успешном совападении
-    паттерна
-    """
+    """Bool-ячейка, которая получает значение True при успешном совпадении паттерна."""
+
     def __init__(self, default=None, pattern=None, match_type=MATCH_IF_EXACT):
+        """Если паттерн опущен (или None), то результат будет True при любой значащей строке в ячейке.
+
+        Параметр default игнорируется (всегда равен False).
         """
-        Если паттерн опущен (или None), то результат будет True при любой
-        значащей строке в ячейке.
-        Параметр default игнорируется (всегда равет False)
-        """
-        super(MaybeTrueCell, self).__init__(
-            default=False, pattern=pattern, match_type=match_type)
+        super().__init__(default=False, pattern=pattern, match_type=match_type)
 
     def _parse(self, value):
-        result, _ = super(MaybeTrueCell, self)._parse(value)
+        result, _ = super()._parse(value)
+
         if result:
             return self.result(True)
         else:
@@ -377,21 +353,18 @@ class MaybeTrueCell(BooleanCell):
 
 
 class MaybeFalseCell(BooleanCell):
-    """
-    Bool-ячейка, которая получает значение False при успешном совападении
-    паттерна
-    """
+    """Bool-ячейка, которая получает значение False при успешном совпадении паттерна."""
+
     def __init__(self, default=None, pattern=None, match_type=MATCH_IF_EXACT):
+        """Если паттерн опущен (или None), то результат будет False при любой значащей строке в ячейке.
+
+        Параметр default игнорируется (всегда равен True).
         """
-        Если паттерн опущен (или None), то результат будет False при любой
-        значащей строке в ячейке.
-        Параметр default игнорируется (всегда равет True)
-        """
-        super(MaybeFalseCell, self).__init__(
-            default=True, pattern=pattern, match_type=match_type)
+        super().__init__(default=True, pattern=pattern, match_type=match_type)
 
     def _parse(self, value):
-        result, _ = super(MaybeFalseCell, self)._parse(value)
+        result, _ = super()._parse(value)
+
         if result:
             return self.result(False)
         else:
@@ -399,16 +372,14 @@ class MaybeFalseCell(BooleanCell):
 
 
 class EnumCell(BaseCell):
-    """
-    Ячейка, которая может принимать одно из заданных значений
-    """
-    def __init__(self, default=_NO_DEFAULT, choices=None,
-                 match_type=MATCH_IF_EXACT, blank_values=None):
-        """
-        choices - список вариантов вида (pattern, value)
-        """
+    """Ячейка, которая может принимать одно из заданных значений."""
+
+    def __init__(self, default=_NO_DEFAULT, choices=None, match_type=MATCH_IF_EXACT, blank_values=None):
+        """choices - список вариантов вида (pattern, value)."""
         assert len(choices) >= 2, 'Должно быть указано хотя бы 2 варианта!'
-        super(EnumCell, self).__init__(default=default)
+
+        super().__init__(default=default)
+
         self.choices = choices
         self.match_type = match_type
         self.blank_values = blank_values
@@ -442,8 +413,7 @@ class DateCell(BaseCell):
         result = None
         try:
             result = datetime(*xlrd.xldate_as_tuple(float(value), 0))
-        except (XLDateNegative, XLDateAmbiguous, XLDateTooLarge,
-                XLDateBadDatemode):
+        except (XLDateNegative, XLDateAmbiguous, XLDateTooLarge, XLDateBadDatemode):
             raise CellValueError(WRONG_DATE_FORMAT_MSG)
         except ValueError:
             value = str(value).strip()[:10]
@@ -464,22 +434,16 @@ class DateCell(BaseCell):
 
 
 class MaybeDateCell(DateCell):
-    """
-    Date или None
-    """
+    """Date или None."""
+
     def __init__(self):
-        super(MaybeDateCell, self).__init__(default=None)
+        super().__init__(default=None)
 
 
 class DynamicStartRow:
-    """
-    Автоматический поиск начала таблицы по ее заголовкам ее столбцов
-    """
+    """Автоматический поиск начала таблицы по ее заголовкам ее столбцов."""
 
-    def __init__(self, table_headers,
-                 order_sensetive=True,
-                 case_sensitive=False,
-                 search_area=[(0, 0), (50, 50)]):
+    def __init__(self, table_headers, order_sensetive=True, case_sensitive=False, search_area=[(0, 0), (50, 50)]):
         """
         :param list table_headers: Список заголовков: ['Фамилия' 'Имя']
         :param bool order_sensetive: Учитывать порядок списка table_headers
@@ -501,7 +465,6 @@ class DynamicStartRow:
             self.table_headers = [s.upper() for s in table_headers]
 
     def find_pos(self, sheet):
-
         max_row = min(self.max_row, sheet.nrows)
         max_col = min(self.max_col, sheet.ncols)
 
@@ -517,7 +480,6 @@ class DynamicStartRow:
                     matched.setdefault(val, col)
 
             if len(matched) == len(self.table_headers):
-
                 cols_nums = [matched[h] for h in self.table_headers]
                 if self.order_sensetive and sorted(cols_nums) != cols_nums:
                     continue
@@ -525,7 +487,6 @@ class DynamicStartRow:
                 return row, min(cols_nums)
 
     def find_row(self, sheet):
-
         pos = self.find_pos(sheet)
         if pos:
             row, col = pos
@@ -533,12 +494,9 @@ class DynamicStartRow:
 
 
 class SimpleColumnMatcher:
-    """
-    Класс сопоставления столбцов таблицы
-    """
+    """Класс сопоставления столбцов таблицы."""
 
-    def __init__(self, column_name, unique_check=False,
-                 strip=True, case_sensitive=False, replacer=None):
+    def __init__(self, column_name, unique_check=False, strip=True, case_sensitive=False, replacer=None):
         """
         :param str column_name: Название столбца
         :param bool unique_check: Нужно ли проверять на то, чтобы данный
@@ -559,7 +517,7 @@ class SimpleColumnMatcher:
         self.replacer = replacer
 
     def get_column_name(self):
-        """Возвращает название столбца"""
+        """Возвращает название столбца."""
         return self.column_name
 
     @property
@@ -567,7 +525,7 @@ class SimpleColumnMatcher:
         return self._unique_check
 
     def _prepare_cell_value(self, cell_value):
-        """Подготовка значения с учетом флагов настроек"""
+        """Подготовка значения с учетом флагов настроек."""
         cell_value = str(cell_value)
         if self.strip:
             cell_value = cell_value.strip()
@@ -581,26 +539,21 @@ class SimpleColumnMatcher:
         return cell_value
 
     def match(self, cell_value):
-        """
-        Проверка: отвечает ли значение в cell_value
-        требуемому названию столбца
-        """
+        """Проверка: отвечает ли значение в cell_value требуемому названию столбца."""
 
         column_name = self.column_name
         if not self.case_sensitive:
             column_name = column_name.upper()
 
         cell_value = self._prepare_cell_value(cell_value)
+
         return cell_value == column_name
 
 
 class RegexColumnMatcher(SimpleColumnMatcher):
-    """
-    Сопоставление столбцов по регулярному выражению
-    """
+    """Сопоставление столбцов по регулярному выражению."""
 
     def __init__(self, column_name, regex, **kwargs):
-
         if isinstance(regex, str):
             flags = re.UNICODE
             if not kwargs.get('case_sensitive'):
@@ -608,10 +561,12 @@ class RegexColumnMatcher(SimpleColumnMatcher):
 
             regex = re.compile(regex, flags)
         self.regex = regex
-        super(RegexColumnMatcher, self).__init__(column_name, **kwargs)
+
+        super().__init__(column_name, **kwargs)
 
     def match(self, cell_value):
         cell_value = self._prepare_cell_value(cell_value)
+
         return bool(self.regex.search(cell_value))
 
 
@@ -619,10 +574,10 @@ class RegexColumnMatcher(SimpleColumnMatcher):
 # XLSLoader
 # =============================================================================
 
+
 class XLSLoader:
-    """
-    Загрузчик xls-файла с разбором
-    """
+    """Загрузчик xls-файла с разбором."""
+
     config = {}
 
     """
@@ -665,14 +620,10 @@ class XLSLoader:
         self._row_errors_log = {}
         self._log_change_flag = False
 
-        self._book = xlrd.open_workbook(
-            file_contents=memory_mapped_file.read())
+        self._book = xlrd.open_workbook(file_contents=memory_mapped_file.read())
 
-        if not all((
-            self._file,
-            self._book.nsheets > 0
-        )):
-            self._log("Не удалось загрузить файл!")
+        if not all((self._file, self._book.nsheets > 0)):
+            self._log('Не удалось загрузить файл!')
             self._book = None
             raise ValueError('See loader log')
 
@@ -694,30 +645,23 @@ class XLSLoader:
                 HEADER_PARSER,
                 # парсер строки шапки листа по-умолчанию:
                 # накапливает в список непустые ячейки
-                lambda x: list(filter(bool, x))
+                lambda x: list(filter(bool, x)),
             )
             self._flat_config[k] = _fold(v)
 
         if self._XLSLoader__RESERVED_SHEET in self._flat_config:
-            raise AssertionError(
-                'Название листа "%s" зарезервировано!' %
-                self._XLSLoader__RESERVED_SHEET
-            )
+            raise AssertionError(f'Название листа "{self._XLSLoader__RESERVED_SHEET}" зарезервировано!')
 
         self._loaded_data = {}
         self._headers = {}
 
     def _log_common_error(self, *items):
-        """
-        Запись в основной лог ошибок
-        """
+        """Запись в основной лог ошибок."""
         self._log_change_flag = True
         self._common_log.extend(items)
 
     def _log_row_error(self, xls_pos, *items):
-        """
-        Добавление ошибки в строке
-        """
+        """Добавление ошибки в строке."""
         self._log_change_flag = True
         self._row_errors_log.setdefault(xls_pos, []).extend(items)
 
@@ -744,9 +688,7 @@ class XLSLoader:
         return self._headers
 
     def load(self):
-        """
-        Загрузка листа по дескриптору колонок строки
-        """
+        """Загрузка листа по дескриптору колонок строки."""
         if self._book is None:
             return False
 
@@ -769,8 +711,7 @@ class XLSLoader:
                 if sheet_name == self._XLSLoader__RESERVED_SHEET:
                     continue
                 for k, v in self._flat_config.items():
-                    if (isinstance(k, int) and (sheet_num + 1) == k) or (
-                            isinstance(k, tuple) and (sheet_num + 1) in k):
+                    if (isinstance(k, int) and (sheet_num + 1) == k) or (isinstance(k, tuple) and (sheet_num + 1) in k):
                         parsers = v
                         parser_key = k
                         break
@@ -780,22 +721,14 @@ class XLSLoader:
                     else:
                         expected_sheets = (
                             key
-                            for key in map(
-                                lambda x: str(x).capitalize(),
-                                self._flat_config
-                            )
+                            for key in map(lambda x: str(x).capitalize(), self._flat_config)
                             if key != self.ANY_SHEET
                         )
 
                         self._log_row_error(
                             (sheet.name, sheet_num + 1, 0),
-                            'Неверное название листа №%s: %s.\n'
-                            'Ожидаемые названия листов: %s' %
-                            (
-                                sheet_num + 1,
-                                sheet.name,
-                                ', '.join(expected_sheets)
-                            ),
+                            f'Неверное название листа №{sheet_num + 1}: {sheet.name}.\n'
+                            f'Ожидаемые названия листов: {", ".join(expected_sheets)}',
                         )
                         continue
 
@@ -816,18 +749,13 @@ class XLSLoader:
             header_data = self._headers.setdefault(parser_key, [])
             for row in range(0, start_row):
                 # парсеру заголовка передаётся итератор ячеек по строкам
-                header_data.append(
-                    header_parser((
-                        sheet.cell(row, i).value for i in range(sheet.ncols)
-                    ))
-                )
+                header_data.append(header_parser((sheet.cell(row, i).value for i in range(sheet.ncols))))
 
             # разбор шапки листа
             col_parsers = []
             errors = []
 
             for path, (col_mather, parser), grp in parsers:
-
                 if isinstance(col_mather, str):
                     col_mather = SimpleColumnMatcher(col_mather)
                 # в шапке могут быть целочисленные ячейки
@@ -847,39 +775,28 @@ class XLSLoader:
                         break
 
                     if col_mather.match(cell_value):
-                        matched_cols.append(
-                            (col, str(cell_value).strip())
-                        )
+                        matched_cols.append((col, str(cell_value).strip()))
 
                 if not matched_cols:
                     if parser.is_obligatory():
                         errors.append(
-                            'На листе "%s" (%s) отсутствует столбец "%s", '
-                            'необходимый для импорта' % (
-                                sheet_name, sheet_num + 1, column_name
-                            )
+                            f'На листе "{sheet_name}" ({sheet_num + 1}) отсутствует столбец "{column_name}", '
+                            'необходимый для импорта'
                         )
 
                 elif col_mather.unique_check and len(matched_cols) > 1:
+                    column_names = ', '.join(f'"{x[1]}"' for x in matched_cols)
                     errors.append(
-                        'На листе "%s" (%s) присутствуют взаимоисключающие '
-                        'столбцы: %s.' % (
-                            sheet_name, sheet_num + 1,
-                            ', '.join('"%s"' % x[1] for x in matched_cols)
-                        )
+                        f'На листе "{sheet_name}" ({sheet_num + 1}) присутствуют взаимоисключающие '
+                        f'столбцы: {column_names}.'
                     )
                 else:
                     col_pos, real_column_name = matched_cols[0]
-                    col_parsers.append(
-                        (col_pos, real_column_name, path, parser, grp)
-                    )
+                    col_parsers.append((col_pos, real_column_name, path, parser, grp))
 
             if errors:
                 for error in errors:
-                    self._log_row_error(
-                        (sheet.name, sheet_num + 1, start_row + 1),
-                        error
-                    )
+                    self._log_row_error((sheet.name, sheet_num + 1, start_row + 1), error)
                 continue
 
             # список результатов связанный с именем листа
@@ -900,19 +817,15 @@ class XLSLoader:
                 filled_cells_counts = {}
 
                 def inc_counter(grp):
-                    filled_cells_counts[grp] = (
-                        filled_cells_counts.get(grp, 0) + 1
-                    )
+                    filled_cells_counts[grp] = filled_cells_counts.get(grp, 0) + 1
 
                 row_errors = {}
 
                 def add_err(grp, title, err):
-                    row_errors.setdefault(grp, set()).add(
-                        'Cтолбец "%s": %s' % (title, err)
-                    )
+                    row_errors.setdefault(grp, set()).add(f'Cтолбец "{title}": {err}')
 
                 def add_warn(grp, title, msg):
-                    message = 'Cтолбец "%s": %s' % (title, msg)
+                    message = f'Cтолбец "{title}": {msg}'
                     self._log_row_error(xls_pos, *[message])
 
                 groups = set()
@@ -978,15 +891,14 @@ class XLSLoader:
         Преобразует словарь-лог ошибок строк в отсортированный список строк
         """
         result = []
-        for pos, lines in sorted(
-            log.items(), key=lambda x: (x[0][1], str(x[0][2]))
-        ):
-            result.append('Лист "%s" (%s), строка %s:' % pos)
-            result.extend(('  %s' % line) for line in sorted(lines))
+        for pos, lines in sorted(log.items(), key=lambda x: (x[0][1], str(x[0][2]))):
+            result.append(f'Лист "{pos[0]}" ({pos[1]}), строка {pos[2]}:')
+            result.extend(f'  {line}' for line in sorted(lines))
             result.append('')
 
         return result
 
+
 if __name__ == '__main__':
 
     def cells_to_pair(cells):
@@ -1002,14 +914,8 @@ if __name__ == '__main__':
                 'date': ('date', DateCell()),
                 'int': ('int', IntCell(default=-100)),
             },
-            'mb_true': (
-                'mb_true',
-                MaybeTrueCell(pattern='y', match_type=MATCH_IF_STARTS_WITH)
-            ),
-            'enum': (
-                'enum',
-                EnumCell(choices=((1, 'aaa'), (2, 'bbb')), default=3)
-            ),
+            'mb_true': ('mb_true', MaybeTrueCell(pattern='y', match_type=MATCH_IF_STARTS_WITH)),
+            'enum': ('enum', EnumCell(choices=((1, 'aaa'), (2, 'bbb')), default=3)),
             'opt_strs': {
                 # SUBTREE_CAN_BE_EMPTY: False,
                 'date': ('date', DateCell()),
@@ -1018,8 +924,7 @@ if __name__ == '__main__':
                 'mb_int': ('mb_int', MaybeIntCell()),
             },
             'pasport': (
-                RegexColumnMatcher(
-                    'Номер паспорта', '^(№|Номер) паспорта$'),
+                RegexColumnMatcher('Номер паспорта', '^(№|Номер) паспорта$'),
                 StringCell(),
             ),
             # Авто определение начала таблицы
@@ -1032,17 +937,14 @@ if __name__ == '__main__':
     with open('test_file.xls') as xls_file:
         ldr = XLSLoader(xls_file, config=config)
 
-        print("Loaded: %s" % ldr.load())
+        print(f'Loaded: {ldr.load()}')
 
         print('---- header ----')
-        print('\n'.join(
-            '%s -> %r' % i
-            for i in ldr.headers['TEST']
-            if i
-        ))
+        print('\n'.join(f'{col} -> {val!r}' for col, val in ldr.headers['TEST'] if (col, val)))
 
         print('---- data ----')
         import pprint
+
         pprint.pprint(ldr.data)
 
         print('---- rows_log ----')