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

educommon/importer/proxy.py

@@ -25,7 +25,6 @@ from educommon.m3 import (
 
 
 class SafeDict(dict):
-
     @classmethod
     def _wrap(cls, value):
         if not value:
@@ -51,14 +50,12 @@ class SafeDict(dict):
 
     def pop(self, *args, **kwargs):
         try:
-            return self._wrap(
-                dict.pop(self, *args, **kwargs)
-            )
+            return self._wrap(dict.pop(self, *args, **kwargs))
         except KeyError:
             return None
 
     def copy(self):
-        return self._wrap(super(SafeDict, self).copy())
+        return self._wrap(super().copy())
 
 
 class ProxySaveError(Exception):
@@ -78,9 +75,8 @@ class ProxyWarning(Exception):
 
 
 class _ImportProxy:
-    """
-    Прототип proxy для загрузки данных
-    """
+    """Прототип proxy для загрузки данных."""
+
     # описание ячеек
     cells_config = {
         # 'key': cell
@@ -106,9 +102,7 @@ class _ImportProxy:
 
     @classmethod
     def __make_config(cls, headers):
-        """
-        Создание конфигурации колонок для XLSLoader`а
-        """
+        """Создание конфигурации колонок для XLSLoader`а."""
         if headers:
             if isinstance(headers, str):
                 # "шапки" могут быть переданы в виде форматирующей строки
@@ -126,7 +120,7 @@ class _ImportProxy:
         def add_headers(src, path=''):
             result = {}
             for key, val in src.items():
-                path_w_key = ('%s__%s' % (path, key)) if path else key
+                path_w_key = f'{path}__{key}' if path else key
                 try:
                     val = add_headers(val, path_w_key)
                 except AttributeError:
@@ -137,35 +131,33 @@ class _ImportProxy:
         return add_headers(cls.cells_config)
 
     def __init__(self, key, context):
-        """
-        Проверка зависимостей.
+        """Проверка зависимостей.
+
         Если контекст не содержит требуемых данных, должно
-        возбуждаться исключение AssertionError
+        возбуждаться исключение AssertionError.
         """
         assert key
         self._key = key
         self._context = context
 
     def _load(self, data):
-        """
-        Загрузка данных из словаря data
+        """Загрузка данных из словаря data.
+
         Допустимое исключение - ProxySaveError.
         """
         raise NotImplementedError()
 
 
 class ModelProxy(_ImportProxy):
-    """
-    Обёртка для импорта модели
-    """
+    """Обёртка для импорта модели."""
+
     # модель
     model = None
 
 
 class CacheProxy(_ImportProxy):
-    """
-    Обёртка для кэша объектов
-    """
+    """Обёртка для кэша объектов."""
+
     model = None
 
     # если задано сообщение, оно будет выведено в случае
@@ -177,20 +169,18 @@ class CacheProxy(_ImportProxy):
     msg_multiple = None
 
     def __init__(self, key, context):
-        super(CacheProxy, self).__init__(key, context)
-        self._key = '%s_cache' % self._key
+        super().__init__(key, context)
+
+        self._key = f'{self._key}_cache'
         self._cache = context.setdefault(self._key, {})
 
     def _make_identity(self, data):
-        """
-        Преобразование данных в параметры для get()
-        """
+        """Преобразование данных в параметры для get()."""
         return data
 
     def _load(self, data):
-        """
-        Возврат объекта из кэша, а если его там нет, то из базы
-        """
+        """Возврат объекта из кэша, а если его там нет, то из базы."""
+
         def wrap_to_q(x):
             if isinstance(x, dict):
                 return Q(**x)
@@ -199,9 +189,7 @@ class CacheProxy(_ImportProxy):
 
         def default():
             try:
-                obj = self.model.objects.get(
-                    wrap_to_q(self._make_identity(data))
-                )
+                obj = self.model.objects.get(wrap_to_q(self._make_identity(data)))
                 obj._imported_object = True
                 return obj
 
@@ -224,54 +212,55 @@ class CacheProxy(_ImportProxy):
 
 
 class ContextAdapterProxy(_ImportProxy):
-    """
-    Прокси для преобразования контекста.
-    """
+    """Прокси для преобразования контекста."""
+
     @classmethod
     def _must_be_executed_anyway(cls, is_optional=False):
-        """
-        Данный прокси вызывается всегда, т.к. обычне не требует данных
-        """
+        """Данный прокси вызывается всегда, т.к. обычно не требует данных."""
         return True
 
     @classmethod
     def make_copier(cls, src_key):
+        """Конструирует простой копирующий адаптер.
+
+        При загрузке извлекает значение по ключу src_key из контекста и возвращает его.
         """
-        Конструирует простой копирующий адаптер, который при загрузке просто
-        извлекает значение по ключу src_key из контекста и возвращает его
-        """
+
         class SimpleCopyingAdepter(cls):
             def _load(self, data):
                 return self._context[src_key]
+
         return SimpleCopyingAdepter
 
     @classmethod
     def make_mover(cls, src_key):
-        """
-        Конструирует простой копирующий адаптер, который при загрузке просто
-        извлекает значение по ключу src_key из контекста и возвращает его,
+        """Конструирует простой копирующий адаптер.
+
+        При загрузке извлекает значение по ключу src_key из контекста и возвращает его,
         а значение контекста по ключу заменяется на None.
         """
+
         class SimpleCopyingAdepter(cls):
             def _load(self, data):
                 result = self._context[src_key]
                 self._context[src_key] = None
                 return result
+
         return SimpleCopyingAdepter
 
     @classmethod
     def make_setter(cls, value):
-        """
-        Конструирует адаптер, который просто возвращает указанное значение
-        """
+        """Конструирует адаптер, который просто возвращает указанное значение."""
+
         class SimpleCopyingAdepter(cls):
             def _load(self, data):
                 return value
+
         return SimpleCopyingAdepter
 
 
 class LayoutModelProxy(ModelProxy):
-    """Прокси для загрузки области данных"""
+    """Прокси для загрузки области данных."""
 
     # словари будут сгенерированы в api
     cells_config, default_headers = None, None
@@ -293,27 +282,24 @@ class LayoutModelProxy(ModelProxy):
             # тип ячейки для этой области
             'cell_type': MaybeStringCell(),
             # отдельные прокси для каждого столбца области
-            'use_separated_proxy': True
+            'use_separated_proxy': True,
         },
     }
 
     @staticmethod
     def create_header(proxy, context):
-        """
-        Построение кэша объектов, используемых в заголовках области
-        Вызывается при добавлении в лоадер
+        """Построение кэша объектов, используемых в заголовках области.
+
+        Вызывается при добавлении в лоадер.
         """
         raise NotImplementedError()
 
 
 class MultiProxyLoader:
-    """
-    Прокси загрузки нескольких моделей
-    """
+    """Прокси загрузки нескольких моделей."""
 
     # начальный контекст импорта
-    initial_context = {
-    }
+    initial_context = {}
 
     # proxy моделей в порядке приоритета
     proxies = [
@@ -347,17 +333,17 @@ class MultiProxyLoader:
 
     @classmethod
     def make_header_context(cls, header_data, context):
-        """
-        Преобразование данных шапки.
-        При возвращении непустого списка ошибок - прекращение загрузки листа
+        """Преобразование данных шапки.
+
+        При возвращении непустого списка ошибок - прекращение загрузки листа.
         """
         header_context = {}
         errors = []
+
         return header_context, errors
 
     @classmethod
-    def load_rows(cls, header_data, rows_data, parse_log, log, context,
-                  warning_log=None, result_logger=None):
+    def load_rows(cls, header_data, rows_data, parse_log, log, context, warning_log=None, result_logger=None):
         """Загрузка строк листа.
 
         Логи разделены с целью дать возможность потомку принять решение
@@ -381,9 +367,7 @@ class MultiProxyLoader:
         # обработчик данных шапки листа
         transaction.enter_transaction_management()
         try:
-            header_context, errors = cls.make_header_context(
-                header_data, context
-            )
+            header_context, errors = cls.make_header_context(header_data, context)
 
         except Exception:
             transaction.rollback()
@@ -402,8 +386,7 @@ class MultiProxyLoader:
             # помеченных декоратором @delay_in_situations(delay_situation).
             # Определение ситуаций.
             if context:
-                delay_situation = context.get(
-                    'delay_situation', cls.default_delay_situation)
+                delay_situation = context.get('delay_situation', cls.default_delay_situation)
             else:
                 delay_situation = cls.default_delay_situation
 
@@ -422,14 +405,11 @@ class MultiProxyLoader:
                         try:
                             errors, warnings = proxyloader.load(row)
                             result_logger.on_row_processed(row[xls_pos])
-                            result_logger.on_row_errors(
-                                row[xls_pos], errors, warnings)
+                            result_logger.on_row_errors(row[xls_pos], errors, warnings)
                         except ProxyCriticalError as err:
-                            log.setdefault(row[xls_pos], []).extend(
-                                [str(err)])
+                            log.setdefault(row[xls_pos], []).extend([str(err)])
                             _errors.append(str(err))
-                            result_logger.on_row_errors(
-                                row[xls_pos], [str(err)])
+                            result_logger.on_row_errors(row[xls_pos], [str(err)])
 
                             # XXX при данном эксепшене нужно предотвратить
                             # повторное выполнение load, поэтому откатываем
@@ -437,20 +417,15 @@ class MultiProxyLoader:
                             transaction.savepoint_rollback(inner_t._sid)
                             # откатываем внешний блок
                             transaction.rollback(outer_t._using)
-                            transaction.leave_transaction_management(
-                                using=outer_t._using)
+                            transaction.leave_transaction_management(using=outer_t._using)
                             break
 
                         if warnings:
                             # предупреждения выводятся отдельно
                             if warning_log is not None:
-                                warning_log.setdefault(
-                                    row[xls_pos], []
-                                ).extend(warnings)
+                                warning_log.setdefault(row[xls_pos], []).extend(warnings)
                             else:
-                                log.setdefault(
-                                    row[xls_pos], []
-                                ).extend(warnings)
+                                log.setdefault(row[xls_pos], []).extend(warnings)
 
                         # предусмотренные ошибки, а все непредвиденные всплывут
                         if errors:  # предвиденные складываем
@@ -459,21 +434,20 @@ class MultiProxyLoader:
                             log.setdefault(row[xls_pos], []).extend(errors)
                             # откатываем вложенную транзакцию (всю строку)
                             # если это не загрузчик прокси с областями
-                            if not hasattr(
-                                proxyloader, 'layout_proxies_template'
-                            ):
+                            if not hasattr(proxyloader, 'layout_proxies_template'):
                                 inner_t.rollback()
-                                result_logger.on_row_save_rollback(
-                                    row[xls_pos])
+                                result_logger.on_row_save_rollback(row[xls_pos])
                         else:
                             result_logger.on_row_save(row[xls_pos])
                 # если были ошибки и нужно откатить всё
                 # FIXME: Если rollback_all == True, то независимо от флага
                 # FIXME: игнора, будет происходить откат
                 if _errors and (cls.rollback_all or not ignore_bad_rows):
-                    log.setdefault(
-                        row[xls_pos][:2] + ('',), []
-                    ).extend([cls.LOAD_ERROR_MSG, ])
+                    log.setdefault(row[xls_pos][:2] + ('',), []).extend(
+                        [
+                            cls.LOAD_ERROR_MSG,
+                        ]
+                    )
                     outer_t.rollback()
                     result_logger.on_save_rollback()
 
@@ -482,10 +456,8 @@ class MultiProxyLoader:
         # с использованием transaction.atomic
         @classmethod
         @transaction.atomic
-        def load_rows(cls, header_data, rows_data, parse_log, log, context,
-                      warning_log=None, result_logger=None):
-            """
-            Загрузка строк листа.
+        def load_rows(cls, header_data, rows_data, parse_log, log, context, warning_log=None, result_logger=None):
+            """Загрузка строк листа.
 
             Логи разделены с целью дать возможность потомку принять решение
             о дальнейшей загрузке, если были ошибки парсинга ячеек.
@@ -519,8 +491,7 @@ class MultiProxyLoader:
                         add_log(row, items)
 
             # обработчик данных шапки листа
-            header_context, header_errors = cls.make_header_context(
-                header_data, context)
+            header_context, header_errors = cls.make_header_context(header_data, context)
 
             if header_errors:
                 # были ошибки в шапке листа, дальше лист не грузится
@@ -563,16 +534,13 @@ class MultiProxyLoader:
                 except ProxyCriticalError as err:
                     rows_errors.append(str(err))
                     add_log(row, [str(err)])
-                    result_logger.on_critical_error(
-                        row[xls_pos], str(err)
-                    )
+                    result_logger.on_critical_error(row[xls_pos], str(err))
                     break
 
             # если были ошибки и нужно откатить всё
             # FIXME: Если rollback_all == True, то независимо от флага
             # FIXME: игнора, будет происходить откат
-            if result_logger.has_error() and (
-                        cls.rollback_all or not ignore_bad_rows):
+            if result_logger.has_error() and (cls.rollback_all or not ignore_bad_rows):
                 key = row[xls_pos][:2] + ('',)
                 log.setdefault(key, []).extend([cls.LOAD_ERROR_MSG])
 
@@ -581,16 +549,17 @@ class MultiProxyLoader:
 
     @classmethod
     def make_config(cls):
-        """
-        Создание конфигурации для XLSLoader`а
-        """
+        """Создание конфигурации для XLSLoader`а."""
+
         def prepare_headers(raw_headers):
-            """
+            """Подготовка заголовка.
+
             Если на входе строка, она оборачивается в словарь-подобный объект,
             который на любой ключ возвращает эту строку.
             Если на входе словарь - он остаётся словарём.
             """
             if isinstance(raw_headers, str):
+
                 class StrAsDict:
                     def __init__(self, value):
                         self._value = value
@@ -602,7 +571,9 @@ class MultiProxyLoader:
                         if isinstance(default, dict):
                             return self
                         return self._value
+
                 return StrAsDict(raw_headers)
+
             return raw_headers
 
         def make_subconfig(headers, options):
@@ -623,24 +594,24 @@ class MultiProxyLoader:
 
                 try:
                     # пробуем построить конфиг для proxy
-                    sub_config.update(value._ImportProxy__make_config(
-                        headers.get(key)
-                    ))
+                    sub_config.update(value._ImportProxy__make_config(headers.get(key)))
                 except AttributeError:
                     # заменяем подопции на {} если они к данному
                     # моменту выродились в булев флаг
-                    sub_options = (
-                        isinstance(sub_options, bool) and {}
-                    ) or sub_options
+                    sub_options = (isinstance(sub_options, bool) and {}) or sub_options
 
                     # строим конфиг для поддерева
-                    sub_config.update(dict(map(
-                        make_subconfig(
-                            prepare_headers(headers.get(key, {})),
-                            sub_options,
-                        ),
-                        value
-                    )))
+                    sub_config.update(
+                        dict(
+                            map(
+                                make_subconfig(
+                                    prepare_headers(headers.get(key, {})),
+                                    sub_options,
+                                ),
+                                value,
+                            )
+                        )
+                    )
 
                 return (key, sub_config)
 
@@ -648,19 +619,21 @@ class MultiProxyLoader:
 
         # начальный вызов
         result = cls.xlsreader_extra.copy()
-        result.update(dict(map(
-            make_subconfig(
-                prepare_headers(cls.headers),
-                cls.optionals,
-            ),
-            cls.proxies
-        )))
+        result.update(
+            dict(
+                map(
+                    make_subconfig(
+                        prepare_headers(cls.headers),
+                        cls.optionals,
+                    ),
+                    cls.proxies,
+                )
+            )
+        )
         return result
 
     def __init__(self, context=None):
-        """
-        Загрузка строки данных
-        """
+        """Загрузка строки данных."""
         self._context = {
             'error_format': self.error_format,
         }
@@ -670,28 +643,25 @@ class MultiProxyLoader:
         self._set_validators()
 
     def _set_validators(self):
-        """
-        Устанавливает валидаторы, которые будут применяться при загрузке.
-        """
+        """Устанавливает валидаторы, которые будут применяться при загрузке."""
         self._validators = []
 
     def _validate(self, data):
-        """
-        Применяет валидаторы ко входным данным.
+        """Применяет валидаторы ко входным данным.
+
         :param data: словарь входных данных
         :return: два списка, список ошибок и список предупреждений.
         """
         errors, warnings = [], []
         for validator in self._validators:
             validator(data, errors, warnings)
+
         return errors, warnings
 
     def load(self, data):
-
         errors, warnings = self._validate(data)
 
         def load_to_proxy(context, options, data, key, proxy):
-
             # проверка на принадлежность proxy к потомкам ImportProxy
             try:
                 is_single_proxy = issubclass(proxy, _ImportProxy)
@@ -730,19 +700,15 @@ class MultiProxyLoader:
                     context[key] = proxy(key, context)._load(sub_data)
                 except ProxyWarning as err:
                     # Записать в лог и продолжить загрузку строки
-                    warnings.append(
-                        (context.error_format or '%s') % str(err)
-                    )
+                    warnings.append((context.error_format or '{}').format(str(err)))
                     raise
                 except (ProxySaveError, ValidationError) as err:
                     # такая ошибка складывается в лог
-                    errors.append(
-                        (context.error_format or '%s') % str(err)
-                    )
+                    errors.append((context.error_format or '{}').format(str(err)))
                     if not is_layout_proxy:
                         # если обычный прокси, вся строка пропускается
                         return False
-                except (ProxyCriticalError, AssertionError) as err:
+                except (ProxyCriticalError, AssertionError):
                     # AssertionError - откатит всю загрузку
                     # ProxyCriticalError - откатит с выводом сообщения
                     raise
@@ -758,13 +724,9 @@ class MultiProxyLoader:
                 sub_data = SafeDict(sub_data)
                 # получаем подопции
                 if isinstance(sub_options, bool):
-                    sub_options = collections.defaultdict(
-                        lambda: sub_options
-                    )
+                    sub_options = collections.defaultdict(lambda: sub_options)
                 for sub_key, sub_proxy in proxy:
-                    if not load_to_proxy(
-                        sub_context, sub_options, sub_data, sub_key, sub_proxy
-                    ):
+                    if not load_to_proxy(sub_context, sub_options, sub_data, sub_key, sub_proxy):
                         return False
                 # из подконтекста атрибут с тем же ключем помещается в контекст
                 context[key] = sub_context[key]
@@ -774,8 +736,7 @@ class MultiProxyLoader:
             if errors:
                 break
             try:
-                proxy_result = load_to_proxy(
-                    self._context, self.optionals, data, key, proxy)
+                proxy_result = load_to_proxy(self._context, self.optionals, data, key, proxy)
             except ProxyWarning:
                 continue
             else:
@@ -786,9 +747,8 @@ class MultiProxyLoader:
 
 
 class LayoutProxyLoader(MultiProxyLoader):
-    """
-    Загрузчик, умеющий генерировать себе прокси по размеченной области
-    """
+    """Загрузчик, умеющий генерировать себе прокси по размеченной области."""
+
     # список кортежей шаблонов для прокси, определяющих область данных листа,
     # которыми будет дополнен основной список proxies
     layout_proxies_template = []
@@ -797,7 +757,7 @@ class LayoutProxyLoader(MultiProxyLoader):
 
     @classmethod
     def add_proxy(cls, key, proxy, add_log, context):
-        """Встраивание прокси для области в список задекларированных прокси"""
+        """Встраивание прокси для области в список задекларированных прокси."""
 
         # обновим копию начального контекста загрузчика контекстом из api
         loader_context = cls.initial_context.copy()
@@ -814,21 +774,16 @@ class LayoutProxyLoader(MultiProxyLoader):
             cls.add_proxy_log.setdefault(key, str(err))
 
     @classmethod
-    def load_rows(cls, header_data, rows_data, parse_log, log, context,
-                  warning_log=None):
-        super(LayoutProxyLoader, cls).load_rows(
-            header_data, rows_data, parse_log, log, context
-        )
+    def load_rows(cls, header_data, rows_data, parse_log, log, context, warning_log=None):
+        super().load_rows(header_data, rows_data, parse_log, log, context)
+
         if cls.add_proxy_log:
-            log.setdefault(
-                rows_data[0][context['XLS_POS']], []
-            ).extend(list(cls.add_proxy_log.values()))
+            log.setdefault(rows_data[0][context['XLS_POS']], []).extend(list(cls.add_proxy_log.values()))
 
 
 def _fabricate_proxy(AncestorCls, name, cells_config, default_headers):
-    """
-    Изготовление прокси области (для загрузчика)
-    по шаблону-прокси и по заданным извне настройкам ячеек
+    """Изготовление прокси области (для загрузчика) по шаблону-прокси и по заданным извне настройкам ячеек.
+
     :param AncestorCls: класс-предок, описывающий области и метод загрузки
     :param name: str - имя области
     :param cells_config: dict,
@@ -836,24 +791,23 @@ def _fabricate_proxy(AncestorCls, name, cells_config, default_headers):
     """
 
     cls = type(
-        name.capitalize(), (AncestorCls,),
+        name.capitalize(),
+        (AncestorCls,),
         {
             'was_fabricated': True,  # для фильтраци при добавлении в загрузчик
             'cells_config': cells_config,
             'default_headers': default_headers,
             # соответствие {модель: (ключ, строка)} для дальнейшего парсинга
-            'layout_header': dict([(
-                AncestorCls.layout_header_model, (k, v)
-            ) for k, v in default_headers.items()]),
-        }
+            'layout_header': dict([(AncestorCls.layout_header_model, (k, v)) for k, v in default_headers.items()]),
+        },
     )
+
     return name, cls
 
 
 def fabricate_proxies(AncestorCls, layout_name, head_data):
-    """
-    Создает настройки ячеек для области и
-    возвращает список кортежей сгенерированных прокси для загрузчика
+    """Создает настройки ячеек для области и возвращает список кортежей сгенерированных прокси для загрузчика.
+
     :param AncestorCls: класс-предок, описывающий области и метод загрузки
     :param layout_name: str - имя области
     :param head_data: list - список строк, определяющий заголовки столбцов
@@ -867,9 +821,9 @@ def fabricate_proxies(AncestorCls, layout_name, head_data):
     # использовать отдельные прокси для каждого столбца
     use_separated_proxy = layout_conf.get('use_separated_proxy', False)
     # заголовки колонок этой области
-    cols = head_data[layout_conf.get('start_col'):layout_conf.get('end_col')]
+    cols = head_data[layout_conf.get('start_col') : layout_conf.get('end_col')]
     for idx, col_name in enumerate(cols):
-        key = '%s%i' % (layout_name, idx)
+        key = f'{layout_name}{idx}'
         if use_separated_proxy:
             cells_config = {key: layout_conf.get('cell_type')}
             default_headers = {key: col_name}
@@ -883,4 +837,5 @@ def fabricate_proxies(AncestorCls, layout_name, head_data):
     if not use_separated_proxy and params:
         # либо генерация одного прокси для всех столбцов
         proxies.append(_fabricate_proxy(*params))
+
     return proxies