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

educommon/importer/proxy_import.py

@@ -21,9 +21,9 @@ class ProxyLoader:
     message = None
     """Сообщение о результате."""
 
-    def __init__(self, loaders, _file, file_name, context=None,
-                 separate_logs=False, ignore_bad_rows=False,
-                 result_logger=None):
+    def __init__(
+        self, loaders, _file, file_name, context=None, separate_logs=False, ignore_bad_rows=False, result_logger=None
+    ):
         """Загрузка файла по словарю прокси-загрузчиков.
 
         :param dict loaders: словарь постраничных загрузчиков файла
@@ -55,8 +55,7 @@ class ProxyLoader:
         :param dict log: лог
         :rtype str
         """
-        return '\n'.join(
-            self.xls_loader.log + self.xls_loader.prepare_row_errors(log))
+        return '\n'.join(self.xls_loader.log + self.xls_loader.prepare_row_errors(log))
 
     def load(self):
         """Импорт данных из файла."""
@@ -96,7 +95,7 @@ class ProxyLoader:
                 loader_cls = self.loaders.get(sheet.upper())
             if not loader_cls:
                 # Если не найден загрузчик для листа
-                error_msg = 'Некорректное имя листа "%s"' % sheet
+                error_msg = f'Некорректное имя листа "{sheet}"'
                 import_log[data[0][self.xls_loader.XLS_POS]] = error_msg
                 # Заносим запись об ошибке при обработке листа в общий лог
                 self.result_logger.on_sheet_errors(sheet, [error_msg])
@@ -110,7 +109,7 @@ class ProxyLoader:
                 log=import_log,
                 context=self.context,
                 warning_log=warning_log,
-                result_logger=self.result_logger
+                result_logger=self.result_logger,
             )
 
         log = self.make_log(import_log)
@@ -120,14 +119,14 @@ class ProxyLoader:
             # если задан режим разделения логов
             if log:
                 # всё же были какие-то ошибки
-                final_log = [" ОШИБКИ:\n ", log]
+                final_log = [' ОШИБКИ:\n ', log]
             else:
-                final_log = [SUCCESFUL_IMPORTED, ]
+                final_log = [
+                    SUCCESFUL_IMPORTED,
+                ]
 
             if warning_log:
-                final_log.extend([
-                    " ПРЕДУПРЕЖДЕНИЯ:\n ", self.make_log(warning_log)
-                ])
+                final_log.extend([' ПРЕДУПРЕЖДЕНИЯ:\n ', self.make_log(warning_log)])
 
             self.message = '\n'.join(final_log)
         else:

educommon/importer/report.py

@@ -13,14 +13,14 @@ from educommon.report.reporter import (
 
 
 class BaseFailureImportReport:
-    """Базовый класс отчета об импорте"""
+    """Базовый класс отчета об импорте."""
 
     template_name = None
     reports_dir = 'reports'
     default_extension = 'xlsx'
 
     def __init__(self, data):
-        """:param data - данные для отчета"""
+        """:param data - данные для отчета."""
 
         self.data = data
         # Текущая директория
@@ -33,9 +33,7 @@ class BaseFailureImportReport:
         self.out_file_path = get_path(self.base_name)
         # url адрес, по которому будет доступен отчет
         self.out_file_url = get_url(self.base_name)
-        self.report = SpreadsheetReport(os.path.join(
-            reports_dir, '%s.%s' % (self.template_name, self.default_extension)
-        ))
+        self.report = SpreadsheetReport(os.path.join(reports_dir, f'{self.template_name}.{self.default_extension}'))
 
         # Создадим директории, если их нет
         folder_path = get_path('')
@@ -43,5 +41,5 @@ class BaseFailureImportReport:
             os.makedirs(folder_path)
 
     def make(self):
-        """Сбор отчета"""
+        """Сбор отчета."""
         raise NotImplementedError

educommon/importer/ui.py

@@ -12,58 +12,61 @@ class BaseImportWindow(BaseEditWindow):
     """Базовое окно загрузки шаблона импорта."""
 
     def _init_components(self):
-        super(BaseImportWindow, self)._init_components()
+        super()._init_components()
+
         self.file_field = ext.ExtFileUploadField(
             anchor='100%',
             allow_blank=False,
             name='uploaded',
-            label="Файл для загрузки",
+            label='Файл для загрузки',
         )
 
     def _do_layout(self):
-        super(BaseImportWindow, self)._do_layout()
+        super()._do_layout()
+
         self.form.items.append(self.file_field)
 
     def set_params(self, params):
-        super(BaseImportWindow, self).set_params(params)
+        super().set_params(params)
+
         self.height = 110
         # FIXME: При переопределении придется копипастить
         # Проброс ID окна для окна результата
-        self.handler_beforesubmit = '''
+        self.handler_beforesubmit = """
             function (submit) {submit.params["import_window_id"] = win.id}
-        '''
+        """
 
         self.form.file_upload = True
         self.save_btn.text = 'Загрузить'
-        self.file_field.possible_file_extensions = params.get(
-            'extensions', None
-        )
+        self.file_field.possible_file_extensions = params.get('extensions', None)
 
 
 class ImportResultWindow(BaseWindow):
     """Окно для вывода результата импорта."""
 
     def _init_components(self):
-        super(ImportResultWindow, self)._init_components()
+        super()._init_components()
+
         self.result_field = ext.ExtTextArea(read_only=True)
 
-        self.close_btn = ext.ExtButton(
-            text='Закрыть',
-            handler='function() {win.close()}'
-        )
+        self.close_btn = ext.ExtButton(text='Закрыть', handler='function() {win.close()}')
 
         # Кнопка "Отмена" не блокируется в режиме "только для чтения"
         self._mro_exclude_list.append(self.close_btn)
 
     def _do_layout(self):
-        super(ImportResultWindow, self)._do_layout()
+        super()._do_layout()
+
         self.items.append(self.result_field)
-        self.buttons.extend([
-            self.close_btn,
-        ])
+        self.buttons.extend(
+            [
+                self.close_btn,
+            ]
+        )
 
     def set_params(self, params):
-        super(ImportResultWindow, self).set_params(params)
+        super().set_params(params)
+
         self.body_style = 'padding: 0;'
         self.layout = 'fit'
         self.modal = False
@@ -75,37 +78,40 @@ class ConfirmImportResultWindow(ImportResultWindow):
     """Окно для подтверждения импорта при наличии ошибок."""
 
     def _init_components(self):
-        super(ConfirmImportResultWindow, self)._init_components()
+        super()._init_components()
+
         self.confirm_import_btn = ext.ExtButton(
             text='Загрузить данные, в которых нет ошибок',
         )
 
     def _do_layout(self):
-        super(ConfirmImportResultWindow, self)._do_layout()
+        super()._do_layout()
+
         self.buttons.insert(0, self.confirm_import_btn)
 
     def set_params(self, params):
-        super(ConfirmImportResultWindow, self).set_params(params)
+        super().set_params(params)
+
         self.parent_window_id = params['import_window_id']
 
         if params.get('exit_from_import_on_close', False):
             # Закрытие окна импорта и окна результата
-            self.close_btn.handler = '''
+            self.close_btn.handler = """
                 function() {
                     if (win.parentWindow) win.parentWindow.close();
                     win.close();
                 }
-            '''
+            """
 
         if params.get('hide_confirm_button', False):
             self.confirm_import_btn.hidden = True
         else:
             # Хэндлер пробрасывает параметр для пропуска ошибок и снова
             # сабмитит форму импорта.
-            self.confirm_import_btn.handler = '''
+            self.confirm_import_btn.handler = """
                 function() {
                     win.close();
                     win.parentWindow.actionContextJson.ignore_bad_rows = true;
                     win.parentWindow.submitForm();
                 }
-            '''
+            """

educommon/importer/validators.py

@@ -1,23 +1,20 @@
-"""
-Базовые валидаторы для импортируемых данных.
+"""Базовые валидаторы для импортируемых данных.
 
 Использовать только для расширения/исправления логики, реализованной с помощью
 `educommon.importer`. При написании новых классов для импорта/экспорта данных
 рекомендуется использовать пакет `data-transfer`.
 """
+
 from abc import (
     ABCMeta,
 )
 
 
 class IImportDataValidator(metaclass=ABCMeta):
-    """
-    Базовый класс валидатора импортируемых данных.
-    """
+    """Базовый класс валидатора импортируемых данных."""
 
     def __call__(self, data_row, errors, warnings):
-        """
-        Валидирует строку входных данных.
+        """Валидирует строку входных данных.
 
         :param data_row: словарь, представляющий одну строку импортируемых
         данных

educommon/integration_entities/helpers.py

@@ -29,8 +29,7 @@ from educommon.integration_entities.enums import (
 
 
 class AbstractEntitySaver(ABC):
-    """
-    Абстрактный класс сохранения записей в моделях.
+    """Абстрактный класс сохранения записей в моделях.
 
     Используется в рамках выгрузок РВД, Сферум и ГИСРУО.
     """
@@ -72,8 +71,7 @@ class AbstractEntitySaver(ABC):
 
     @property
     def _to_delete_entities(self) -> Union[list, Iterable[Model]]:
-        """
-        Возвращает записи для удаления.
+        """Возвращает записи для удаления.
 
         Частный случай, поэтому по умолчанию возвращает пустой список.
         """
@@ -119,16 +117,14 @@ class AbstractEntitySaver(ABC):
         )
 
     def _delete_entities(self) -> None:
-        """
-        Удаляет записи или обрабатывает записи для удаления.
+        """Удаляет записи или обрабатывает записи для удаления.
 
         Частный случай, поэтому метод мало где может пригодиться.
         """
 
 
 class EntitySaver(AbstractEntitySaver):
-    """
-    Стандартный класс для сохранения моделей.
+    """Стандартный класс для сохранения моделей.
 
     Стандартный, потому что используется в большинстве случаев.
     """
@@ -171,25 +167,25 @@ class EntitySaverWithRealDeleting(EntitySaver):
 
 
 class ChainEntitySaver(AbstractEntitySaver):
-    """
-    Класс для сохранения моделей.
+    """Класс для сохранения моделей.
 
     Chain, потому что формирование объектов для сохранения происходит с помощью itertools.chain
     """
 
     def _get_entities_base(self, operation_type: EntityLogOperation) -> Iterable[Model]:
         """Базовый метод, возвращающий объекты для сохранения в зависимости от типа операции."""
-        return chain.from_iterable([
-            entities.values()
-            for operation_entities in self._to_save_entities.values()
-            for operation, entities in operation_entities.items()
-            if operation == operation_type
-        ])
+        return chain.from_iterable(
+            [
+                entities.values()
+                for operation_entities in self._to_save_entities.values()
+                for operation, entities in operation_entities.items()
+                if operation == operation_type
+            ]
+        )
 
 
 class IterableEntitySaver(AbstractEntitySaver):
-    """
-    Класс для сохранения моделей.
+    """Класс для сохранения моделей.
 
     Iterable, потому что формирование объектов для сохранения происходит в цикле.
     Используется в gis_ruo.

educommon/ioc/__init__.py

@@ -4,6 +4,7 @@
 При необходимости использования в общей кодовой базе объектов проекта,
 нужно добавить переменные со значением ``educommon.Undefined`` в данный модуль.
 """
+
 from educommon import (
     Undefined,
 )
@@ -85,9 +86,7 @@ def register(name, value):
     if globals()[name] is value:
         return value
 
-    assert globals()[name] is Undefined, (
-        '"{}" already registered'.format(name)
-    )
+    assert globals()[name] is Undefined, '"{}" already registered'.format(name)
 
     globals()[name] = value
 
@@ -100,8 +99,6 @@ def get(name):
     *name* должен быть предварительно зарегистрирован через **register**.
     """
     assert name in globals(), 'Object {} is not registered'.format(name)
-    assert globals()[name] is not Undefined, (
-        '"{}" not registered'.format(name)
-    )
+    assert globals()[name] is not Undefined, '"{}" not registered'.format(name)
 
     return globals()[name]

educommon/logger/loggers.py

@@ -29,9 +29,7 @@ _srcfile = os.path.normcase(addLevelName.__code__.co_filename)
 
 
 class WebEduLogger(getLoggerClass()):
-    """
-    Расширенный логер для работы с различными версиями Python.
-    """
+    """Расширенный логер для работы с различными версиями Python."""
 
     def makeRecord(
         self,
@@ -46,9 +44,7 @@ class WebEduLogger(getLoggerClass()):
         extra: Optional[Mapping[str, object]] = ...,
         sinfo: Optional[str] = ...,
     ) -> WebEduLogRecord:
-        """
-        Метод формирования записи лога.
-        """
+        """Метод формирования записи лога."""
         rv = WebEduLogRecord(name, level, fn, lno, msg, args, exc_info, func)
 
         if extra:
@@ -71,16 +67,16 @@ class WebEduLogger(getLoggerClass()):
         stacklevel=1,
         request=None,
     ):
-        """
-        Low-level logging routine which creates a LogRecord and then calls
-        all the handlers of this logger to handle the record.
+        """Низкоуровневая процедура логирования.
+
+        Создает LogRecord и передает его всем обработчикам данного логгера.
         """
         sinfo = None
 
         if _srcfile:
-            #IronPython doesn't track Python frames, so findCaller raises an
-            #exception on some versions of IronPython. We trap it here so that
-            #IronPython can use logging.
+            # IronPython doesn't track Python frames, so findCaller raises an
+            # exception on some versions of IronPython. We trap it here so that
+            # IronPython can use logging.
             try:
                 python_version = platform.python_version()
 
@@ -90,9 +86,9 @@ class WebEduLogger(getLoggerClass()):
                     fn, lno, func, sinfo = self.findCaller(stack_info, stacklevel)
 
             except ValueError:  # pragma: no cover
-                fn, lno, func = "(unknown file)", 0, "(unknown function)"
+                fn, lno, func = '(unknown file)', 0, '(unknown function)'
         else:  # pragma: no cover
-            fn, lno, func = "(unknown file)", 0, "(unknown function)"
+            fn, lno, func = '(unknown file)', 0, '(unknown function)'
 
         if exc_info:
             if isinstance(exc_info, BaseException):

educommon/m3/__init__.py

@@ -1,4 +1,5 @@
 """Вспомогательные средства для работы с компонентами M3."""
+
 import inspect
 import sys
 from functools import (
@@ -72,6 +73,7 @@ def convert_validation_error_to(exc, new_line='<br/>', model=None):
         Если аргумент указан, то данные будут извлекаться именно из этой
         модели.
     """
+
     def get_model_meta(error):
         if model is not None:
             return model._meta
@@ -85,31 +87,24 @@ def convert_validation_error_to(exc, new_line='<br/>', model=None):
         if 'self' not in error_frame.f_locals:
             raise
         model_instance = error_frame.f_locals['self']
+
         return model_instance._meta
 
     def get_messages_from_dict(model_meta, data):
         result = []
         for field_name, field_errors in data.items():
             if field_name == NON_FIELD_ERRORS:
-                result.append(
-                    new_line.join(
-                        '- {0}'.format(err) for err in field_errors
-                    )
-                )
+                result.append(new_line.join('- {0}'.format(err) for err in field_errors))
             else:
                 model_field = model_meta.get_field(field_name)
-                verbose_name = (model_field.verbose_name or '')
-                result.append(new_line.join(
-                    '- {0}: {1}'.format(verbose_name, err)
-                    for err in field_errors
-                ))
+                verbose_name = model_field.verbose_name or ''
+                result.append(new_line.join('- {0}: {1}'.format(verbose_name, err) for err in field_errors))
+
         return result
 
     def get_messages_from_list(messages):
-        result = [
-            '- ' + message
-            for message in messages
-        ]
+        result = ['- ' + message for message in messages]
+
         return result
 
     assert issubclass(exc, Exception), type(exc)
@@ -127,8 +122,7 @@ def convert_validation_error_to(exc, new_line='<br/>', model=None):
 
                 if hasattr(e, 'message_dict'):
                     title = 'На форме имеются некорректно заполненные поля:'
-                    messages = [title] + get_messages_from_dict(model_meta,
-                                                                e.message_dict)
+                    messages = [title] + get_messages_from_dict(model_meta, e.message_dict)
                 else:
                     title = 'При проверке данных найдены ошибки:'
                     messages = [title] + get_messages_from_list(e.messages)
@@ -155,12 +149,10 @@ class ModelProxyValidationMixin:
         model_errors = error.update_error_dict({})
 
         for field_name, messages in model_errors.items():
-
             # В зависимости от версии Django в messages могут быть
             # как сообщения в виде строк, так и экземпляры ValidationError,
             # поэтому приводим его к списку, содержащему только строки
-            messages = sum([m.messages if isinstance(
-                m, DjangoValidationError) else [m] for m in messages], [])
+            messages = sum([m.messages if isinstance(m, DjangoValidationError) else [m] for m in messages], [])
 
             if field_name != NON_FIELD_ERRORS:
                 full_field_name = '.'.join((model_name, field_name))
@@ -216,9 +208,7 @@ class ModelProxyValidationMixin:
         errors = {}
 
         models = (  # элементы составной модели
-            name
-            for name in (list(self.relations) + [primary_model_name])
-            if not exclude or name not in exclude
+            name for name in (list(self.relations) + [primary_model_name]) if not exclude or name not in exclude
         )
 
         for model_name in models:
@@ -250,8 +240,7 @@ class ModelProxyValidationMixin:
                 try:
                     model.full_clean(model_exclude)
                 except DjangoValidationError as error:
-                    errors = self.__update_error_dict(error, errors,
-                                                      model_name)
+                    errors = self.__update_error_dict(error, errors, model_name)
                     if not errors:
                         valid_key = '_ModelValidationMixin__object_is_valid'
                         model.__dict__[valid_key] = True
@@ -296,10 +285,9 @@ class PackValidationMixin:
         from objectpack.slave_object_pack.actions import (
             SlavePack,
         )
+
         if isinstance(self, SlavePack):
-            obj.__dict__.update(
-                self._get_parents_dict(context, key_fmt='%s_id')
-            )
+            obj.__dict__.update(self._get_parents_dict(context, key_fmt='%s_id'))
             save_row = super(SlavePack, self).save_row
         else:
             save_row = super(PackValidationMixin, self).save_row
@@ -336,14 +324,8 @@ def get_pack(pack_or_model):
     """
     observer = ioc.get('observer')
 
-    if (
-        (
-            isinstance(pack_or_model, str) and
-            '.' in pack_or_model
-        ) or (
-            inspect.isclass(pack_or_model) and
-            issubclass(pack_or_model, ActionPack)
-        )
+    if (isinstance(pack_or_model, str) and '.' in pack_or_model) or (
+        inspect.isclass(pack_or_model) and issubclass(pack_or_model, ActionPack)
     ):
         # Пак задан именем класса в пакете или классом
         result = ControllerCache.find_pack(pack_or_model)
@@ -376,6 +358,7 @@ def get_pack_id(pack_or_model):
     """
     pack = get_pack(pack_or_model)
     result = pack.id_param_name
+
     return result
 
 
@@ -396,13 +379,12 @@ def get_id_value(context, pack_or_model):
     :param pack_or_model: Аргумент, определяющий пак, из которого будет
         получено имя параметра, идентифицирующего объект (*id_param_name*).
     """
-    assert isinstance(
-        context, ObservableController.VerboseDeclarativeContext
-    ), type(context)
+    assert isinstance(context, ObservableController.VerboseDeclarativeContext), type(context)
 
     if isinstance(pack_or_model, (Action, ActionPack)):
         pack_or_model = pack_or_model.__class__
 
     pack = get_pack(pack_or_model)
     result = getattr(context, pack.id_param_name)
+
     return result

educommon/m3/extensions/__init__.py

@@ -1,4 +1,5 @@
 """Утилиты для расширения интерфейсов и действий."""
+
 from educommon.m3.extensions.listeners import (
     BaseEditWinListener,
     BaseSaveListener,