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

educommon/report/constructor/builders/excel/_base.py

@@ -128,28 +128,17 @@ class FilterValuesProvider:
         """
 
         if column_descriptor.data_type == constants.CT_CHOICES:
-            return get_field_value_by_display(
-                column_descriptor.field,
-                value
-            ) if self._as_orm_filter else value
+            return get_field_value_by_display(column_descriptor.field, value) if self._as_orm_filter else value
         else:
             if isinstance(column_descriptor.field.formfield(), BooleanField):
-                if (
-                    isinstance(value, str) and
-                    value.lower() in ('false', '0', 'нет')
-                ):
+                if isinstance(value, str) and value.lower() in ('false', '0', 'нет'):
                     return False if self._as_orm_filter else FALSE
 
-                elif (
-                    isinstance(value, str) and
-                    value.lower() in ('true', '1', 'да')
-                ):
+                elif isinstance(value, str) and value.lower() in ('true', '1', 'да'):
                     return True if self._as_orm_filter else TRUE
 
                 else:
-                    raise FilterError(
-                        report_filter, 'неправильно задано значение фильтра'
-                    )
+                    raise FilterError(report_filter, 'неправильно задано значение фильтра')
 
             return column_descriptor.field.formfield().to_python(value)
 
@@ -168,33 +157,19 @@ class FilterValuesProvider:
             result = None
 
         elif report_filter.operator == constants.IN:
-            result = tuple(
-                self.to_python(value, report_filter, column_descriptor)
-                for value in report_filter.values
-            )
+            result = tuple(self.to_python(value, report_filter, column_descriptor) for value in report_filter.values)
 
         elif report_filter.operator == constants.BETWEEN:
-            result = tuple(
-                self.to_python(value, report_filter, column_descriptor)
-                for value in report_filter.values
-            )
+            result = tuple(self.to_python(value, report_filter, column_descriptor) for value in report_filter.values)
 
             if len(result) != 2:
-                raise FilterError(
-                    report_filter, 'не правильно заданы границы диапазона'
-                )
+                raise FilterError(report_filter, 'не правильно заданы границы диапазона')
 
         elif report_filter.values:
-            result = self.to_python(
-                report_filter.values[0],
-                report_filter,
-                column_descriptor
-            )
+            result = self.to_python(report_filter.values[0], report_filter, column_descriptor)
 
         else:
-            raise FilterError(
-                report_filter, 'не указано значение для сравнения.'
-            )
+            raise FilterError(report_filter, 'не указано значение для сравнения.')
 
         return result
 
@@ -204,10 +179,7 @@ def is_row(data):
 
     :rtype: bool
     """
-    return (
-        isinstance(data, (tuple, list)) and
-        any(not isinstance(cell, (tuple, list)) for cell in data)
-    )
+    return isinstance(data, (tuple, list)) and any(not isinstance(cell, (tuple, list)) for cell in data)
 
 
 def is_block(data):
@@ -215,11 +187,7 @@ def is_block(data):
 
     :rtype: bool
     """
-    return (
-        data and
-        isinstance(data, (tuple, list)) and
-        all(isinstance(row, (tuple, list)) for row in data)
-    )
+    return data and isinstance(data, (tuple, list)) and all(isinstance(row, (tuple, list)) for row in data)
 
 
 def get_data_width(data):
@@ -255,9 +223,7 @@ class _FilterBuilder:
             educommon.report.constructor.base.ColumnDescriptor
         """
         assert isinstance(report_filter, ReportFilter), type(report_filter)
-        assert isinstance(column_descriptor, ColumnDescriptor), type(
-            column_descriptor
-        )
+        assert isinstance(column_descriptor, ColumnDescriptor), type(column_descriptor)
 
         self._report_filter = report_filter
         self._column_descriptor = column_descriptor
@@ -271,10 +237,7 @@ class _FilterBuilder:
 
         :param str field_lookup: lookup-выражение для доступа к значению поля
         """
-        if (
-            not self._report_filter.case_sensitive and
-            self._column_descriptor.data_type == constants.CT_TEXT
-        ):
+        if not self._report_filter.case_sensitive and self._column_descriptor.data_type == constants.CT_TEXT:
             field_lookup += {
                 constants.EQ: '__iexact',
                 constants.CONTAINS: '__icontains',
@@ -303,16 +266,14 @@ class _FilterBuilder:
             values = True
 
         elif (
-            not self._report_filter.case_sensitive and
-            self._column_descriptor.data_type == constants.CT_TEXT and
-            self._report_filter.operator == constants.IN
+            not self._report_filter.case_sensitive
+            and self._column_descriptor.data_type == constants.CT_TEXT
+            and self._report_filter.operator == constants.IN
         ):
             values = tuple(v.lower() for v in self._report_filter.values)
 
         else:
-            values = FilterValuesProvider()(
-                self._report_filter, self._column_descriptor
-            )
+            values = FilterValuesProvider()(self._report_filter, self._column_descriptor)
 
         return values
 
@@ -327,18 +288,17 @@ class _FilterBuilder:
 
         if self._report_filter.operator == constants.IS_NULL:
             if self._column_descriptor.data_type == constants.CT_TEXT:
-                result = Q(
-                    Q(**{field_lookup + '__isnull': True}) |
-                    Q(**{field_lookup: ''})
-                )
+                result = Q(Q(**{f'{field_lookup}__isnull': True}) | Q(**{field_lookup: ''}))
             else:
-                result = Q(**{field_lookup + '__isnull': True})
+                result = Q(**{f'{field_lookup}__isnull': True})
 
         else:
             try:
-                result = Q(**{
-                    self._get_lookup(field_lookup): filter_values,
-                })
+                result = Q(
+                    **{
+                        self._get_lookup(field_lookup): filter_values,
+                    }
+                )
             except ValueError as error:
                 raise FilterError(self._report_filter, str(error))
 
@@ -362,9 +322,7 @@ class _FilterGroupBuilder:
             educommon.report.constructor.models.ReportFilterGroup
         """
         assert isinstance(data_filterer, _DataFilterer), type(data_filterer)
-        assert isinstance(filter_group, ReportFilterGroup), type(
-            filter_group
-        )
+        assert isinstance(filter_group, ReportFilterGroup), type(filter_group)
 
         self._data_filterer = data_filterer
         self._filter_group = filter_group
@@ -382,13 +340,9 @@ class _FilterGroupBuilder:
 
         for report_filter in self._data_filterer.filters_by_id.values():
             if report_filter.group_id == self._filter_group.id:
-                column_descriptor = data_source.get_column_descriptor(
-                    report_filter.column.name
-                )
+                column_descriptor = data_source.get_column_descriptor(report_filter.column.name)
                 if isinstance(column_descriptor.field, models.Field):
-                    filter_builder = _FilterBuilder(
-                        report_filter, column_descriptor
-                    )
+                    filter_builder = _FilterBuilder(report_filter, column_descriptor)
                     yield filter_builder.get_orm_filter()
 
     def get_orm_filter(self):
@@ -402,18 +356,12 @@ class _FilterGroupBuilder:
         }
 
         if self._filter_group.operator not in operators:
-            raise ApplicationLogicException(
-                'Неподдерживаемый оператор: {}'
-                .format(self._filter_group.operator)
-            )
+            raise ApplicationLogicException('Неподдерживаемый оператор: {}'.format(self._filter_group.operator))
 
         orm_filters = tuple(self._get_nested_orm_filters())
 
         if orm_filters:
-            result = reduce(
-                operators[self._filter_group.operator],
-                orm_filters
-            )
+            result = reduce(operators[self._filter_group.operator], orm_filters)
         else:
             result = Q()
 
@@ -429,8 +377,7 @@ class _DataFilterer:
         2. Фильтрация полученных данных в приложении.
     """
 
-    def __init__(self, report_template, data_source_descriptor,
-                 report_columns, ignored_columns_ids):
+    def __init__(self, report_template, data_source_descriptor, report_columns, ignored_columns_ids):
         """Инициализация экземпляра класса.
 
         :param report_template: Шаблон фильтра.
@@ -447,9 +394,7 @@ class _DataFilterer:
         :param ignored_columns_ids: Колонки исключенные из отчета.
         :type: tuple
         """
-        assert isinstance(report_template, ReportTemplate), type(
-            report_template
-        )
+        assert isinstance(report_template, ReportTemplate), type(report_template)
 
         self._report_template = report_template
         self.data_source_descriptor = data_source_descriptor
@@ -464,14 +409,9 @@ class _DataFilterer:
         """
         query = ReportFilter.objects.filter(
             group__report_template=self._report_template,
-        ).exclude(
-            column_id__in=self._ignored_columns_ids
-        )
+        ).exclude(column_id__in=self._ignored_columns_ids)
 
-        return {
-            report_filter.id: report_filter
-            for report_filter in query
-        }
+        return {report_filter.id: report_filter for report_filter in query}
 
     def get_orm_filters(self):
         """Возвращает фильтры для формирования SQL-запроса.
@@ -486,9 +426,7 @@ class _DataFilterer:
 
         :rtype: django.db.models.Q
         """
-        filter_group = self._report_template.filter_groups.filter(
-            parent__isnull=True
-        ).first()
+        filter_group = self._report_template.filter_groups.filter(parent__isnull=True).first()
 
         if filter_group:
             return _FilterGroupBuilder(self, filter_group).get_orm_filter()
@@ -501,84 +439,82 @@ class _DataFilterer:
         :rtype: callable
         """
         data_source = self.data_source_descriptor
-        column_descriptor = data_source.get_column_descriptor(
-            report_filter.column.name
-        )
-        filter_values = FilterValuesProvider(as_orm_filter=False)(
-            report_filter, column_descriptor
-        )
+        column_descriptor = data_source.get_column_descriptor(report_filter.column.name)
+        filter_values = FilterValuesProvider(as_orm_filter=False)(report_filter, column_descriptor)
 
         if report_filter.operator == constants.LE:
+
             def function(value):
                 return value is not None and value <= filter_values
 
         elif report_filter.operator == constants.LT:
+
             def function(value):
                 return value is not None and value < filter_values
 
         elif report_filter.operator == constants.EQ:
+
             def function(value):
                 return value == filter_values
 
         elif report_filter.operator == constants.GT:
+
             def function(value):
                 return value is not None and value > filter_values
 
         elif report_filter.operator == constants.GE:
+
             def function(value):
                 return value is not None and value >= filter_values
 
         elif report_filter.operator == constants.IS_NULL:
+
             def function(value):
                 return value is None or value == ''
 
         elif report_filter.operator == constants.CONTAINS:
-            assert isinstance(filter_values, str), type(
-                filter_values
-            )
+            assert isinstance(filter_values, str), type(filter_values)
 
             if report_filter.case_sensitive:
+
                 def function(value):
                     return value is not None and filter_values in value
             else:
+
                 def function(value):
-                    return value is not None and any(
-                        v.lower() in value
-                        for v in filter_values
-                    )
+                    return value is not None and any(v.lower() in value for v in filter_values)
 
         elif report_filter.operator == constants.STARTS_WITH:
-            assert isinstance(filter_values, str), type(
-                filter_values
-            )
+            assert isinstance(filter_values, str), type(filter_values)
 
             if report_filter.case_sensitive:
+
                 def function(value):
                     return value is not None and value.startswith(filter_values)
             else:
+
                 def function(value):
                     return value is not None and value.lower().startswith(filter_values.lower())
 
         elif report_filter.operator == constants.ENDS_WITH:
-            assert isinstance(filter_values, str), type(
-                filter_values
-            )
+            assert isinstance(filter_values, str), type(filter_values)
 
             if report_filter.case_sensitive:
+
                 def function(value):
                     return value is not None and value.endswith(filter_values)
             else:
+
                 def function(value):
                     return value is not None and value.lower().endswith(filter_values.lower())
 
         elif report_filter.operator == constants.BETWEEN:
             if report_filter.case_sensitive:
+
                 def function(value):
-                    return (
-                        value is not None and
-                        filter_values[0] <= value <= filter_values[1]
-                    )
+                    return value is not None and filter_values[0] <= value <= filter_values[1]
             else:
+
                 def function(value):
                     if isinstance(value, str):
                         value = value.lower()
@@ -586,28 +522,22 @@ class _DataFilterer:
                     else:
                         values = filter_values
 
-                    return (
-                        value is not None and
-                        values[0] <= value <= values[1]
-                    )
+                    return value is not None and values[0] <= value <= values[1]
 
         elif report_filter.operator == constants.IN:
             assert isinstance(filter_values, tuple), type(filter_values)
 
             if report_filter.case_sensitive:
+
                 def function(value):
                     return value in filter_values
             else:
+
                 def function(value):
                     return value.lower() in (v.lower() for v in filter_values)
 
         else:
-            raise FilterError(
-                report_filter,
-                'Неподдерживаемый оператор ({})'.format(
-                    report_filter.operator
-                )
-            )
+            raise FilterError(report_filter, 'Неподдерживаемый оператор ({})'.format(report_filter.operator))
 
         if report_filter.exclude:
             return lambda value: not function(value)
@@ -626,14 +556,11 @@ class _DataFilterer:
         втором случае --- будут удалены записи во внутренних блоках.
         """
         filter_functions = {
-            report_filter.column_id: self._get_function_for_filter(
-                report_filter
-            )
+            report_filter.column_id: self._get_function_for_filter(report_filter)
             for report_filter in self.filters_by_id.values()
         }
         filter_functions_by_column = tuple(
-            filter_functions.get(report_column.pk)
-            for report_column in self._report_columns
+            filter_functions.get(report_column.pk) for report_column in self._report_columns
         )
 
         def filter_function(row_data, column_functions=None):
@@ -648,8 +575,7 @@ class _DataFilterer:
                 column_functions = column_functions[cell_width:]
 
                 if is_block(cell):
-                    filtered_block = _filter_block_or_row(
-                        cell, column_filter_functions)
+                    filtered_block = _filter_block_or_row(cell, column_filter_functions)
                     if filtered_block is None:
                         return None
                     result.append(filtered_block)
@@ -657,10 +583,7 @@ class _DataFilterer:
                     # Простое значение (не строка или блок)
                     assert not is_row(cell), cell
                     column_filter_function = column_filter_functions[0]
-                    if (
-                            column_filter_function and
-                            not column_filter_function(cell)
-                    ):
+                    if column_filter_function and not column_filter_function(cell):
                         return None
                     result.append(cell)
 
@@ -670,8 +593,7 @@ class _DataFilterer:
             """Возвращет отфильтрованный блок/строку или None."""
             if is_row(block_or_row):
                 return filter_function(block_or_row, column_filter_functions)
-            filtered = [_filter_block_or_row(item, column_filter_functions)
-                        for item in block_or_row]
+            filtered = [_filter_block_or_row(item, column_filter_functions) for item in block_or_row]
             filtered = [item for item in filtered if item is not None]
             return filtered or None
 
@@ -722,9 +644,7 @@ class _DataSorter:
             столбцы были добавлены в шаблон отчета до того, как были удалены
             из моделей Системы).
         """
-        assert isinstance(report_template, ReportTemplate), type(
-            report_template
-        )
+        assert isinstance(report_template, ReportTemplate), type(report_template)
 
         self._report_template = report_template
         self._ignored_columns_ids = ignored_columns_ids
@@ -732,11 +652,11 @@ class _DataSorter:
     @cached_property
     def _params(self):
         data = enumerate(
-            self._report_template.columns.exclude(
-                id__in=self._ignored_columns_ids
-            ).order_by(
+            self._report_template.columns.exclude(id__in=self._ignored_columns_ids)
+            .order_by(
                 'index',
-            ).values_list(
+            )
+            .values_list(
                 'sorting__index',
                 'sorting__direction',
             )
@@ -775,10 +695,7 @@ class _DataSorter:
                         values[sort_index] = _OrderInverter(cell)
                 index += 1
 
-        result = tuple(
-            values[sort_index]
-            for sort_index in sorted(values)
-        )
+        result = tuple(values[sort_index] for sort_index in sorted(values))
 
         return result
 
@@ -806,8 +723,7 @@ class _DataSorter:
                     index += 1
 
         nullable_rows = filter(self._is_row_nullable, rows)
-        non_nullable_rows = filter(
-            lambda _row: not self._is_row_nullable(_row), rows)
+        non_nullable_rows = filter(lambda _row: not self._is_row_nullable(_row), rows)
 
         sorted_rows = sorted(
             non_nullable_rows,
@@ -870,15 +786,12 @@ class DataLoader:
            (
                ('СДЮШОР1', 'Бокс'),
                ('СДЮШОР1', 'Фехтование'),
-           )
+           ),
        )
     """
 
-    def __init__(self, report_template, data_source, report_columns,
-                 ignored_columns_ids, user):
-        assert isinstance(report_template, ReportTemplate), type(
-            report_template
-        )
+    def __init__(self, report_template, data_source, report_columns, ignored_columns_ids, user):
+        assert isinstance(report_template, ReportTemplate), type(report_template)
         self._report_template = report_template
         self._data_source = data_source
         self._report_columns = report_columns
@@ -889,9 +802,7 @@ class DataLoader:
     def _get_column_count(columns):
         # Для иерархии столбцов возвращает количество занимаемых столбцов.
         if columns:
-            return sum(map(
-                DataLoader._get_column_count, columns.values()
-            ))
+            return sum(map(DataLoader._get_column_count, columns.values()))
         else:
             return 1
 
@@ -924,9 +835,9 @@ class DataLoader:
                     attr_value = getattr(obj, attr_name)
                 except AttributeError:
                     if (
-                        hasattr(obj, 'report_constructor_params') and
-                        'extra' in obj.report_constructor_params and
-                        attr_name in obj.report_constructor_params['extra']
+                        hasattr(obj, 'report_constructor_params')
+                        and 'extra' in obj.report_constructor_params
+                        and attr_name in obj.report_constructor_params['extra']
                     ):
                         # Дополнительное поле.
                         extra = obj.report_constructor_params['extra']
@@ -940,34 +851,24 @@ class DataLoader:
                         else:
                             raise
 
-                if (
-                    attr_value is not None and
-                    isinstance(field, (models.BooleanField,
-                                       models.NullBooleanField))
-                ):
-                    attr_value = (
-                        TRUE if attr_value else FALSE
-                    )
+                if attr_value is not None and isinstance(field, (models.BooleanField, models.NullBooleanField)):
+                    attr_value = TRUE if attr_value else FALSE
         else:
             attr_value = obj
             descriptor = None
 
         # Обратная связь или M2M. Такие данные выводятся в виде кортежа.
-        if (
-            attr_name and
-            (
-                isinstance(field, ForeignObjectRel) and
-                hasattr(descriptor, 'related_manager_cls') and
-                isinstance(attr_value, descriptor.related_manager_cls) or
-                isinstance(field, models.ManyToManyField) and
-                isinstance(attr_value, Manager)
-            )
+        if attr_name and (
+            isinstance(field, ForeignObjectRel)
+            and hasattr(descriptor, 'related_manager_cls')
+            and isinstance(attr_value, descriptor.related_manager_cls)
+            or isinstance(field, models.ManyToManyField)
+            and isinstance(attr_value, Manager)
         ):
             objects = attr_value.all()
             if objects:
                 related_obj_data_gen = (
-                    list(DataLoader._get_object_data(related_obj, None, nested))
-                    for related_obj in objects
+                    list(DataLoader._get_object_data(related_obj, None, nested)) for related_obj in objects
                 )
                 yield list(itertools.takewhile(bool, related_obj_data_gen))
             else:
@@ -977,9 +878,7 @@ class DataLoader:
         elif nested:
             if attr_value:
                 for k, v in nested.items():
-                    for object_data in (
-                        DataLoader._get_object_data(attr_value, k, v)
-                    ):
+                    for object_data in DataLoader._get_object_data(attr_value, k, v):
                         yield object_data
             else:
                 for _ in range(DataLoader._get_column_count(nested)):
@@ -991,22 +890,14 @@ class DataLoader:
                 inner_values = []
                 for inner_value in attr_value:
                     if getattr(field.base_field, 'flatchoices', False):
-                        inner_values.append(
-                            DataLoader._get_field_display(
-                                field.base_field, inner_value
-                            )
-                        )
+                        inner_values.append(DataLoader._get_field_display(field.base_field, inner_value))
                     else:
                         inner_values.append(inner_value)
-                yield list(
-                    (str(value),) for value in inner_values
-                )
+                yield list((str(value),) for value in inner_values)
 
             # Поле с choices.
             elif getattr(field, 'flatchoices', False):
-                yield DataLoader._get_field_display(
-                    field, attr_value
-                )
+                yield DataLoader._get_field_display(field, attr_value)
 
             # Поле с данными.
             else:
@@ -1015,10 +906,7 @@ class DataLoader:
     @cached_property
     def _data_filterer(self):
         """Фильтратор данных отчета."""
-        return _DataFilterer(
-            self._report_template, self._data_source, self._report_columns,
-            self._ignored_columns_ids
-        )
+        return _DataFilterer(self._report_template, self._data_source, self._report_columns, self._ignored_columns_ids)
 
     @cached_property
     def _data_aggregator(self):
@@ -1027,30 +915,27 @@ class DataLoader:
 
     def _available_units_filter(self, query):
         """Фильтратор данных отчета по доступности учреждений."""
-        return self._data_source.add_source_filter(
-            query, self._report_template.include_available_units,
-            self._user
-        )
+        return self._data_source.add_source_filter(query, self._report_template.include_available_units, self._user)
 
     def _get_objects(self):
         result = self._data_source.model.objects.all()
         # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
         # Добавление фильтров в запрос.
 
-        if ReportFilter.objects.filter(
-            column__report_template=self._report_template,
-        ).exclude(
-            column_id__in=self._ignored_columns_ids
-        ).exists():
+        if (
+            ReportFilter.objects.filter(
+                column__report_template=self._report_template,
+            )
+            .exclude(column_id__in=self._ignored_columns_ids)
+            .exists()
+        ):
             # Является ли модель древовидной(mptt - Modified Preorder Tree Traversal)
             if hasattr(self._data_source.model, '_mptt_meta'):
-                result = result.filter(
-                    self._data_filterer.get_orm_filters()
-                ).distinct(self._data_source.model._mptt_meta.tree_id_attr)
+                result = result.filter(self._data_filterer.get_orm_filters()).distinct(
+                    self._data_source.model._mptt_meta.tree_id_attr
+                )
             else:
-                result = result.filter(
-                    self._data_filterer.get_orm_filters()
-                ).distinct('pk')
+                result = result.filter(self._data_filterer.get_orm_filters()).distinct('pk')
         # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
         # Добавление параметров включения вложенных учреждений.
 
@@ -1063,9 +948,7 @@ class DataLoader:
         filter_function = self._data_filterer.get_filter_function()
 
         for obj in self._get_objects():
-            row_data = list(
-                DataLoader._get_object_data(obj, None, columns_hierarchy)
-            )
+            row_data = list(DataLoader._get_object_data(obj, None, columns_hierarchy))
             if row_data and any(row_data):
                 row_data = filter_function(row_data)
                 if row_data:
@@ -1073,16 +956,16 @@ class DataLoader:
                     yield row_data
 
     def __iter__(self):
-        column_names = self._report_template.columns.filter(
-            visible=True,
-        ).exclude(
-            pk__in=self._ignored_columns_ids
-        ).values_list('name', flat=True)
+        column_names = (
+            self._report_template.columns.filter(
+                visible=True,
+            )
+            .exclude(pk__in=self._ignored_columns_ids)
+            .values_list('name', flat=True)
+        )
 
         if not column_names:
-            raise ReportConstructorException(
-                'В шаблоне нет ни одного отображаемого столбца.'
-            )
+            raise ReportConstructorException('В шаблоне нет ни одного отображаемого столбца.')
 
         columns_hierarchy = get_columns_hierarchy(*column_names)
 
@@ -1108,9 +991,7 @@ class ReportBuilderBase(metaclass=abc.ABCMeta):
 
         :param str file_path: Путь к файлу отчета.
         """
-        assert isinstance(report_template, ReportTemplate), type(
-            report_template
-        )
+        assert isinstance(report_template, ReportTemplate), type(report_template)
 
         if report_template.data_source_name not in registry:
             raise DataSourceParamsNotFound(report_template.data_source_name)
@@ -1133,11 +1014,7 @@ class ReportBuilderBase(metaclass=abc.ABCMeta):
 
         :rtype: tuple
         """
-        return tuple(
-            self._report_template.columns.exclude(
-                pk__in=self._ignored_columns_ids
-            )
-        )
+        return tuple(self._report_template.columns.exclude(pk__in=self._ignored_columns_ids))
 
     @cached_property
     def _ignored_columns_ids(self):
@@ -1146,8 +1023,7 @@ class ReportBuilderBase(metaclass=abc.ABCMeta):
         :rtype: set
         """
         ignored_columns = set()
-        for col_id, col_name in self._report_template.columns.values_list(
-                'id', 'name'):
+        for col_id, col_name in self._report_template.columns.values_list('id', 'name'):
             if self._data_source.is_column_ignored(col_name):
                 ignored_columns.add(col_id)
 
@@ -1161,20 +1037,21 @@ class ReportBuilderBase(metaclass=abc.ABCMeta):
         """
         return list(
             DataLoader(
-                self._report_template, self._data_source, self._report_columns,
-                self._ignored_columns_ids, self._user
+                self._report_template, self._data_source, self._report_columns, self._ignored_columns_ids, self._user
             )
         )
 
     @cached_property
     def _workbook(self):
         """Книга Excel, в которой формируется отчет."""
-        result = Workbook(self._file_path, dict(
-            default_date_format='dd.mm.yyyy',
-        ))
+        result = Workbook(
+            self._file_path,
+            dict(
+                default_date_format='dd.mm.yyyy',
+            ),
+        )
 
-        for cell_format in (result.default_date_format,
-                            result.default_url_format):
+        for cell_format in (result.default_date_format, result.default_url_format):
             cell_format.set_border()
             cell_format.set_align('vcenter')
 
@@ -1267,9 +1144,8 @@ class ColumnCounter(BaseColumnAggregator):
     title = 'Количество'
 
     def __init__(self, column_index, by_value, total, **kwargs):
-        super(ColumnCounter, self).__init__(
-            column_index, by_value, total, **kwargs
-        )
+        super(ColumnCounter, self).__init__(column_index, by_value, total, **kwargs)
+
         # Требуется ли вывод в итоге количества уникальных значений.
         self.__is_total_unique = kwargs.get('total_unique', False)
 
@@ -1318,21 +1194,14 @@ def get_column_aggregator_info(column):
     :return: Тип агрегатора, (промежуточный итог, итог, количество уникальных)
     :rtype: tuple
     """
-    if (
-        column.by_value == BY_VALUE_COUNT or
-        column.total in (TOTAL_COUNT, TOTAL_UNIQUE_COUNT)
-    ):
+    if column.by_value == BY_VALUE_COUNT or column.total in (TOTAL_COUNT, TOTAL_UNIQUE_COUNT):
         return COUNT, (
             column.by_value == BY_VALUE_COUNT,
             column.total == TOTAL_COUNT,
-            column.total == TOTAL_UNIQUE_COUNT
+            column.total == TOTAL_UNIQUE_COUNT,
         )
     elif column.by_value == BY_VALUE_SUM or column.total == TOTAL_SUM:
-        return SUM, (
-            column.by_value == BY_VALUE_SUM,
-            column.total == TOTAL_SUM,
-            None
-        )
+        return SUM, (column.by_value == BY_VALUE_SUM, column.total == TOTAL_SUM, None)
     else:
         return None, (None, None, None)
 
@@ -1353,16 +1222,11 @@ class DataAggregator:
 
     def set_aggregator(self, aggregator):
         """Добавляет агрегатор."""
-        self._aggregators[aggregator.type] = dict(
-            cls=aggregator,
-            instances=dict()
-        )
+        self._aggregators[aggregator.type] = dict(cls=aggregator, instances=dict())
 
     def get_column_aggregator(self, column, column_idx):
         """Возвращает агрегатор для колонки."""
-        aggregator_type, (by_value, total, total_unique) = (
-            get_column_aggregator_info(column)
-        )
+        aggregator_type, (by_value, total, total_unique) = get_column_aggregator_info(column)
         aggregator = self._aggregators.get(aggregator_type)
         if not aggregator:
             return
@@ -1413,7 +1277,8 @@ class DataAggregator:
                 aggregator.column_index,
                 aggregator.data.items(),
             )
-            for aggregator in aggregators if aggregator.is_by_value
+            for aggregator in aggregators
+            if aggregator.is_by_value
         )
         for title, col_idx, data in aggregators_data:
             for idx, (value, value_data) in enumerate(data):
@@ -1423,24 +1288,16 @@ class DataAggregator:
                     row_data = self.get_empty_row()
                     rows.append(row_data)
 
-                row_data[col_idx] = (
-                    '{} "{}": {}'.format(title, value, value_data)
-                )
+                row_data[col_idx] = '{} "{}": {}'.format(title, value, value_data)
 
     def _extend_rows_by_count(self, rows):
         """Добавляет строки с количеством элементов."""
-        counters = sorted(
-            self._aggregators[COUNT]['instances'].values(),
-            key=lambda c: c.column_index
-        )
+        counters = sorted(self._aggregators[COUNT]['instances'].values(), key=lambda c: c.column_index)
         self._extend_rows(counters, rows)
 
     def _extend_rows_by_sum(self, rows):
         """Добавляет строки с суммой элементов."""
-        summators = sorted(
-            self._aggregators[SUM]['instances'].values(),
-            key=lambda c: c.column_index
-        )
+        summators = sorted(self._aggregators[SUM]['instances'].values(), key=lambda c: c.column_index)
         self._extend_rows(summators, rows)
 
     def get_total_row(self):
@@ -1449,14 +1306,9 @@ class DataAggregator:
         for aggregator in self._aggregators.values():
             for instance in aggregator['instances'].values():
                 if instance.is_total:
-                    row[instance.column_index] = 'Итог({}): {}'.format(
-                        instance.title,
-                        instance.total
-                    )
+                    row[instance.column_index] = 'Итог({}): {}'.format(instance.title, instance.total)
                 elif instance.is_total_unique:
-                    row[instance.column_index] = (
-                        'Итог(Уникальных): {}'.format(instance.total_unique)
-                    )
+                    row[instance.column_index] = 'Итог(Уникальных): {}'.format(instance.total_unique)
 
         return row