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

educommon/django/db/validators/simple.py

@@ -1,4 +1,5 @@
 """Валидаторы для простых (текстовых, числовых и т.п.) полей модели Django."""
+
 import re
 from datetime import (
     datetime,
@@ -50,12 +51,13 @@ class SNILSValidator(RegexValidator):
         содержит значение, несоответствующее формату СНИЛС, либо контрольное
         число некорректно.
     """
+
     regex = _snils_re.pattern
     message = 'СНИЛС должен быть в формате ###-###-### ##'
     flags = _snils_re.flags
 
     def __call__(self, value):
-        super(SNILSValidator, self).__call__(value)
+        super().__call__(value)
         snils_checksum_validator(value)
 
 
@@ -71,8 +73,7 @@ def snils_checksum_validator(value):
     if summa > 101:
         summa %= 101
 
-    if (summa < 100 and summa != checksum or
-            summa in (100, 101) and checksum != 0):
+    if summa < 100 and summa != checksum or summa in (100, 101) and checksum != 0:
         raise ValidationError('не пройдена проверка контрольного числа')
 
 
@@ -81,6 +82,7 @@ regex_snils_validator = SNILSValidator()
 
 # для совместимости со старым валидатором-функцией
 def snils_validator(value):
+    """Проверка корректности СНИЛС с помощью регулярного выражения и контрольной суммы."""
     value = str(value)
 
     regex_snils_validator(value)
@@ -95,6 +97,7 @@ is_snils_valid = partial(validate_value, validator=snils_validator)
 
 
 def _check_inn_checksum(coefficients, numbers, checksum):
+    """Проверка контрольного числа ИНН с использованием весовых коэффициентов."""
     summa = sum(c * n for c, n in zip(coefficients, numbers))
     if summa % 11 % 10 != checksum:
         raise ValidationError('Не пройдена проверка контрольного числа')
@@ -114,9 +117,7 @@ def inn10_validator(value):
     if len(value) != 10 or not value.isdigit():
         raise ValidationError('ИНН должен быть 10-ти значным числом')
 
-    _check_inn_checksum((2, 4, 10, 3, 5, 9, 4, 6, 8),
-                        (int(ch) for ch in value[:-1]),
-                        int(value[-1]))
+    _check_inn_checksum((2, 4, 10, 3, 5, 9, 4, 6, 8), (int(ch) for ch in value[:-1]), int(value[-1]))
 
 
 def inn12_validator(value):
@@ -133,13 +134,9 @@ def inn12_validator(value):
     if len(value) != 12 or not value.isdigit():
         raise ValidationError('ИНН должен быть 12-ти значным числом')
 
-    _check_inn_checksum((7, 2, 4, 10, 3, 5, 9, 4, 6, 8),
-                        (int(ch) for ch in value[:-2]),
-                        int(value[-2]))
+    _check_inn_checksum((7, 2, 4, 10, 3, 5, 9, 4, 6, 8), (int(ch) for ch in value[:-2]), int(value[-2]))
 
-    _check_inn_checksum((3, 7, 2, 4, 10, 3, 5, 9, 4, 6, 8),
-                        (int(ch) for ch in value[:-1]),
-                        int(value[-1]))
+    _check_inn_checksum((3, 7, 2, 4, 10, 3, 5, 9, 4, 6, 8), (int(ch) for ch in value[:-1]), int(value[-1]))
 
 
 def inn_validator(value):
@@ -206,19 +203,13 @@ def checksum_pr_50_1_024(value):
     Если в случае повторного расчета остаток от деления вновь сохраняется
     равным 10, то значение контрольного числа проставляется равным 0.
     """
-    summa = sum(
-        int(digit) * weight
-        for digit, weight in zip(value, cycle(list(range(1, 11))))
-    )
+    summa = sum(int(digit) * weight for digit, weight in zip(value, cycle(list(range(1, 11)))))
 
     remainder = summa % 11
     if remainder < 10:
         result = remainder
     else:
-        summa = sum(
-            int(digit) * weight
-            for digit, weight in zip(value, cycle(list(range(3, 13))))
-        )
+        summa = sum(int(digit) * weight for digit, weight in zip(value, cycle(list(range(3, 13)))))
         remainder = summa % 11
         if remainder < 10:
             result = remainder
@@ -249,9 +240,7 @@ def okato_validator(value):
             raise ValidationError('Не пройдена проверка контрольного числа')
 
     elif value_length not in (2, 5, 8, 11):
-        raise ValidationError(
-            'Код ОКАТО должен состоять из 2, 5, 8 или 11 цифр'
-        )
+        raise ValidationError('Код ОКАТО должен состоять из 2, 5, 8 или 11 цифр')
 
 
 is_okato_valid = partial(validate_value, validator=okato_validator)
@@ -269,9 +258,7 @@ def oktmo_validator(value):
 
     value_length = len(value)
     if value_length not in (2, 5, 8, 11):
-        raise ValidationError(
-            'ОКТМО не может состоять из {} цифр'.format(value_length)
-        )
+        raise ValidationError('ОКТМО не может состоять из {} цифр'.format(value_length))
 
 
 is_oktmo_valid = partial(validate_value, validator=oktmo_validator)
@@ -304,7 +291,7 @@ def _check_ogrn_checksum(value):
     """
     value_length = len(value)  # количество цифр в ОГРН
     divisor = value_length - 2  # делитель для вычисления контрольного числа
-    number = int(value[:value_length - 1])  # ОГРН
+    number = int(value[: value_length - 1])  # ОГРН
     control_number = int(value[-1])  # контрольное число
 
     if number % divisor % 10 != control_number:
@@ -312,16 +299,17 @@ def _check_ogrn_checksum(value):
 
 
 def _ogrn_validator(value, valid_length, title):
+    """Общая логика для проверки ОГРН и ОГРНИП.
+
+    Проверяет длину и контрольное число.
+    """
     value = str(value)
 
     if not value.isdigit():
         raise ValidationError('ОГРН должен состоять только из цифр')
     if len(value) not in valid_length:
         raise ValidationError(
-            '{} должен состоять из {} цифр!'.format(
-                title,
-                ' или '.join(str(l) for l in valid_length)
-            )
+            '{} должен состоять из {} цифр!'.format(title, ' или '.join(str(length) for length in valid_length))
         )
 
     _check_ogrn_checksum(value)
@@ -373,9 +361,7 @@ def okved_validator(value):
 
     value_length = len(value)
     if value_length < 2 or 6 < value_length:
-        raise ValidationError(
-            'Код ОКВЭД не может состоять из {} цифр'.format(value_length)
-        )
+        raise ValidationError('Код ОКВЭД не может состоять из {} цифр'.format(value_length))
 
 
 is_okved_valid = partial(validate_value, validator=okved_validator)
@@ -434,26 +420,18 @@ def validate_file_mime_type(file, allowed_mime_types):
     file.seek(0, 0)
     file_mime_type = magic.from_buffer(file.read(), mime=True)
     if file_mime_type not in allowed_mime_types:
-        raise ValidationError(
-            'Mime type файла не соотвествует допустимым в системе'
-        )
+        raise ValidationError('Mime type файла не соотвествует допустимым в системе')
 
 
 @deconstructible
 class FileMimeTypeValidator:
     """Валидатор для FileField модели проверяющий mimetype файла."""
 
-    message = (
-        'Mime type файла не допустим для загрузки в системе.'
-    )
+    message = 'Mime type файла не допустим для загрузки в системе.'
     code = 'invalid_mimetype'
 
     def __init__(self, allowed_extensions, message=None, code=None):
-        self.allowed_extensions = [
-            allowed_extension.lower()
-            for allowed_extension
-            in allowed_extensions
-        ]
+        self.allowed_extensions = [allowed_extension.lower() for allowed_extension in allowed_extensions]
 
         self.allowed_mime_types = set(
             get_mime_type_for_extension(extension)
@@ -545,7 +523,6 @@ class OptionalFieldValidator(IModelValidator):
 
 
 class RequiredBooleanValidator(OptionalFieldValidator):
-
     """Валидатор обязательного поля ``BooleanField``.
 
     Пример:
@@ -554,7 +531,9 @@ class RequiredBooleanValidator(OptionalFieldValidator):
 
         class Model(BaseModel):
             accept_rules = models.BooleanField(...)
-            validators = [RequiredBooleanValidator('accept_rules'),]
+            validators = [
+                RequiredBooleanValidator('accept_rules'),
+            ]
     """
 
     def __init__(self, field_name, **kwargs):
@@ -562,7 +541,7 @@ class RequiredBooleanValidator(OptionalFieldValidator):
 
         :param str field_name: имя валидируемого поля
         """
-        super(RequiredBooleanValidator, self).__init__(field_name, **kwargs)
+        super().__init__(field_name, **kwargs)
         self.empty_values = (False,)
 
     def _need_check(self, instance):
@@ -589,9 +568,12 @@ class RequiredFieldValidator(OptionalFieldValidator):
             # должно быть обязательным
             employee = models.ForeignKey(
                 'employee.Employee',
-                null=True, blank=True,
+                null=True,
+                blank=True,
             )
-            validators = [RequiredFieldValidator('employee'),]
+            validators = [
+                RequiredFieldValidator('employee'),
+            ]
     """
 
     def _need_check(self, instance):
@@ -607,7 +589,6 @@ class RequiredFieldValidator(OptionalFieldValidator):
 
 
 class UnchangeableFieldValidator(IModelValidator):
-
     """Валидатор неизменяемого поля.
 
     При редактировании объекта, если изменяется поле ``field_name``,
@@ -619,7 +600,9 @@ class UnchangeableFieldValidator(IModelValidator):
 
         class Model(BaseModel):
             type = models.BooleanField(...)
-            validators = [UnchangeableFieldValidator('type'),]
+            validators = [
+                UnchangeableFieldValidator('type'),
+            ]
 
     """
 
@@ -642,12 +625,9 @@ class UnchangeableFieldValidator(IModelValidator):
 
         :rtype: str
         """
-        verbose_name = instance._meta.get_field(
-            self.field_name
-        ).verbose_name
-        return 'Поле "{}" не доступно для редактирования.'.format(
-            verbose_name
-        )
+        verbose_name = instance._meta.get_field(self.field_name).verbose_name
+
+        return 'Поле "{}" не доступно для редактирования.'.format(verbose_name)
 
     def clean(self, instance, errors):
         """Проверка редактирования поля ``field_name``.
@@ -669,7 +649,6 @@ class UnchangeableFieldValidator(IModelValidator):
 
 
 class DuplicationValidator(IModelValidator):
-
     """Валидатор уникальности объекта.
 
     Используется для объектов, уникальность которых нельзя проверить
@@ -734,11 +713,8 @@ class DuplicationValidator(IModelValidator):
 
         :rtype: str
         """
-        return (
-            'В системе уже существует {} с такими же значениями полей {}.'
-        ).format(
-            instance._meta.verbose_name,
-            ', '.join(self._get_field_names(instance))
+        return ('В системе уже существует {} с такими же значениями полей {}.').format(
+            instance._meta.verbose_name, ', '.join(self._get_field_names(instance))
         )
 
     def _get_base_query(self, instance):
@@ -762,9 +738,7 @@ class DuplicationValidator(IModelValidator):
         :type errors: collections.OrderedDict
         """
         original = get_original_object(instance)
-        query = self._get_base_query(instance).filter(
-            self._get_duplication_params(instance)
-        )
+        query = self._get_base_query(instance).filter(self._get_duplication_params(instance))
 
         if original:
             query = query.exclude(id=instance.id)
@@ -774,12 +748,10 @@ class DuplicationValidator(IModelValidator):
 
 
 class SingleErrorDecimalValidator(DecimalValidator):
-
     """Кастомный класс валидации Decimal поля модели."""
 
     def __init__(self, max_digits, decimal_places):
-        super(SingleErrorDecimalValidator, self).__init__(
-            max_digits, decimal_places)
+        super().__init__(max_digits, decimal_places)
         self.max_whole_digits = max_digits - decimal_places
 
     def __call__(self, value):
@@ -808,8 +780,11 @@ class SingleErrorDecimalValidator(DecimalValidator):
                 code='max_decimal_places',
                 params={'max': self.decimal_places},
             )
-        if (self.max_digits is not None and self.decimal_places is not None and
-                whole_digits > (self.max_digits - self.decimal_places)):
+        if (
+            self.max_digits is not None
+            and self.decimal_places is not None
+            and whole_digits > (self.max_digits - self.decimal_places)
+        ):
             raise ValidationError(
                 self.messages['max_whole_digits'],
                 code='max_whole_digits',
@@ -821,13 +796,14 @@ class SingleErrorDecimalValidator(DecimalValidator):
 # Валидаторы персональных данных
 # =============================================================================
 
+
 class FIOValidator(RegexValidator):
     regex = r'(^$)|(^[a-zA-Zа-яА-ЯёЁ]([\s-]?[a-zA-Zа-яА-ЯёЁ])*$)'
 
 
-def date_range_validator(minimum=None, maximum=None,
-                         range_message=None, min_message=None,
-                         max_message=None, date_format='%d.%m.%Y'):
+def date_range_validator(
+    minimum=None, maximum=None, range_message=None, min_message=None, max_message=None, date_format='%d.%m.%Y'
+):
     """Валидатор даты. Возвращает функцию, в которую должен быть помещен один
     аргумент: проверяемое значение
     :param minimum: значение, меньше которого value быть не должно;
@@ -857,11 +833,9 @@ def date_range_validator(minimum=None, maximum=None,
     :return: функция, в которую передается проверяемое значение и которая ведет
     себя как обычный валидатор поля Django
     """
-    assert minimum is not None or maximum is not None, (
-        'Необходимо определелить границы для валидатора дат')
+    assert minimum is not None or maximum is not None, 'Необходимо определелить границы для валидатора дат'
 
-    range_message = (range_message or (
-        'Значение %(val)s не входит в диапазон %(min)s-%(max)s'))
+    range_message = range_message or ('Значение %(val)s не входит в диапазон %(min)s-%(max)s')
     min_message = min_message or 'Значение %(val)s меньше, чем %(min)s'
     max_message = max_message or 'Значение %(val)s больше %(max)s'
 
@@ -876,8 +850,9 @@ def date_range_validator(minimum=None, maximum=None,
     max_date = maximum or datetime.max.date()
     date_format = date_format
 
-    return partial(_date_range_validator, min_date=min_date, max_date=max_date,
-                   message=message, date_format=date_format)
+    return partial(
+        _date_range_validator, min_date=min_date, max_date=max_date, message=message, date_format=date_format
+    )
 
 
 def _date_range_validator(value, min_date, max_date, message, date_format):
@@ -895,12 +870,14 @@ def _date_range_validator(value, min_date, max_date, message, date_format):
     :raises ValidationError
     """
     # должны быть все аргументы
-    assert all([
-        min_date is not None,
-        max_date is not None,
-        message is not None,
-        date_format is not None,
-    ]), 'Все аргументы должны быть указаны (см. сигнатуру функции)'
+    assert all(
+        [
+            min_date is not None,
+            max_date is not None,
+            message is not None,
+            date_format is not None,
+        ]
+    ), 'Все аргументы должны быть указаны (см. сигнатуру функции)'
 
     if isinstance(value, datetime):
         value = value.date()
@@ -915,9 +892,7 @@ def _date_range_validator(value, min_date, max_date, message, date_format):
     }
 
     if not _min <= value <= _max:
-        raise ValidationError(
-            message % message_values
-        )
+        raise ValidationError(message % message_values)
 
 
 class HouseValidator(RegexValidator):
@@ -935,10 +910,8 @@ class HouseValidator(RegexValidator):
     то регулярку нужно будет расширить до
     '^(?=.{,20}$)([0-9IVXА-ЯЁа-яё"/_,.-]{1,} ?){1,}\b$'
     """
-    regex = re.compile(
-        r'^(?=.{,12}$)([0-9а-яё"/_,.-]{1,} ?){1,}\b$',
-        re.IGNORECASE | re.UNICODE
-    )
+
+    regex = re.compile(r'^(?=.{,12}$)([0-9а-яё"/_,.-]{1,} ?){1,}\b$', re.IGNORECASE | re.UNICODE)
     message = 'Неверно указан номер дома'
 
 
@@ -946,6 +919,7 @@ regex_house_validator = HouseValidator()
 
 
 def house_validator(value):
+    """Функция для валидации номера дома."""
     value = str(value)
 
     regex_house_validator(value)
@@ -956,6 +930,7 @@ is_house_number_valid = partial(validate_value, validator=house_validator)
 
 class BuildingValidator(RegexValidator):
     """Валидатор номера корпуса дома."""
+
     regex = re.compile(r'^[0-9а-яё/_.-]{0,10}$', re.IGNORECASE | re.UNICODE)
     message = 'Неверно указан корпус дома'
 
@@ -978,6 +953,7 @@ regex_doc_type_validator = DocumentTypeValidator()
 
 
 def doc_type_validator(value):
+    """Функция для валидации строки с типом документа."""
     value = str(value)
 
     regex_doc_type_validator(value)
@@ -997,14 +973,10 @@ class PassportNumberValidator(RegexValidator):
 
 
 class DocumentSeriesValidator(RegexValidator):
-    regex = (
-        r'(^$)|(^[a-zA-Zа-яА-ЯёЁ\d]([\s|\-|\.|\,|\\|\/]?[a-zA-Zа-яА-ЯёЁ\d])*$)'
-    )
+    regex = r'(^$)|(^[a-zA-Zа-яА-ЯёЁ\d]([\s|\-|\.|\,|\\|\/]?[a-zA-Zа-яА-ЯёЁ\d])*$)'
     message = 'Неверно задана серия документа'
 
 
 class DocumentNumberValidator(RegexValidator):
-    regex = (
-        r'(^$)|(^[a-zA-Zа-яА-ЯёЁ\d]([\s|\-|\.|\,|\\|\/]?[a-zA-Zа-яА-ЯёЁ\d])*$)'
-    )
+    regex = r'(^$)|(^[a-zA-Zа-яА-ЯёЁ\d]([\s|\-|\.|\,|\\|\/]?[a-zA-Zа-яА-ЯёЁ\d])*$)'
     message = 'Неверно задан номер документа'

educommon/django/storages/atcfs/api.py

@@ -17,32 +17,33 @@ from educommon.django.storages.atcfs.exceptions import (
 
 
 class AtcfsApi:
-    """
-    Класс для работы с запросами к ATCFS
-    """
+    """Класс для работы с запросами к ATCFS."""
 
     def _build_url(self, *args):
-        """
-        Функция составления полного урла.
+        """Функция составления полного урла.
+
         :param args: составные части пути
         :return: фбсолютный урл
         """
         chunks = (settings.URL,) + args
         url = '/'.join(chunks)
+
         return url
 
     def _get_credential_headers(self):
-        """
-        Метод генерации данных для аутентификации на сервере ATCFS.
+        """Метод генерации данных для аутентификации на сервере ATCFS.
+
         :return: словарь с необходимыми для атунетификации полями
         """
         request_id = str(uuid.uuid4())
-        sign = '{vis_id}_{vis_user}_{request_id}_{secret_key}'.format(**{
-            'vis_id': settings.VIS_ID,
-            'vis_user': settings.VIS_USER,
-            'request_id': request_id,
-            'secret_key': settings.SECRET_KEY,
-        })
+        sign = '{vis_id}_{vis_user}_{request_id}_{secret_key}'.format(
+            **{
+                'vis_id': settings.VIS_ID,
+                'vis_user': settings.VIS_USER,
+                'request_id': request_id,
+                'secret_key': settings.SECRET_KEY,
+            }
+        )
         sign = hashlib.md5(sign).hexdigest()
         headers = {
             'AtcFs-VisId': settings.VIS_ID,
@@ -50,11 +51,12 @@ class AtcfsApi:
             'AtcFs-RequestId': request_id,
             'AtcFs-Sign': sign,
         }
+
         return headers
 
     def _send_request(self, method, url, headers=None, params=None, data=None):
-        """
-        Отправка запроса
+        """Отправка запроса.
+
         :param method: get|post|delete
         :param url: URL, на который отправляется запрос
         :param headers: дополнительные заголовки
@@ -71,18 +73,18 @@ class AtcfsApi:
                 headers=full_headers,
                 params=params,
                 data=data,
-                timeout=(settings.CONNECT_TIMEOUT, None)
+                timeout=(settings.CONNECT_TIMEOUT, None),
             )
         except (
             requests.exceptions.ConnectionError,
             requests.exceptions.ConnectTimeout,
-            requests.packages.urllib3.exceptions.ConnectTimeoutError
+            requests.packages.urllib3.exceptions.ConnectTimeoutError,
         ):
             raise AtcfsUnavailable()
 
     def upload_file(self, name, content):
-        """
-        Загрузка файла на сервер ATCFS
+        """Загрузка файла на сервер ATCFS.
+
         :param name: название файла
         :param content: содержимое файла
         :return: идентификатор файла на сервере ATCFS
@@ -91,34 +93,24 @@ class AtcfsApi:
         headers = {'Content-Type': 'application/octet-stream'}
         params = {'fileName': name}
         data = content
-        response = self._send_request(
-            method='post',
-            url=url,
-            headers=headers,
-            params=params,
-            data=data
-        )
+        response = self._send_request(method='post', url=url, headers=headers, params=params, data=data)
         if response.status_code != 201:
             raise Exception(response.text)
         ident = response.text
+
         return ident
 
     def download_file(self, ident):
-        """
-        Загружаем файл с сервера в память.
+        """Загружаем файл с сервера в память.
+
         :param ident: идентификатор файла
         :return: тюпл название и содержимое
         """
         url = self._build_url(settings.FILES_PATH, ident)
-        response = self._send_request(
-            method='get',
-            url=url
-        )
+        response = self._send_request(method='get', url=url)
         if response.status_code != 200:
             raise Exception(response.text)
-        _, params = cgi.parse_header(
-            response.headers.get('Content-Disposition')
-        )
+        _, params = cgi.parse_header(response.headers.get('Content-Disposition'))
         file_name = params['filename*']
         try:
             file_name = re.findall(r'UTF-8\'\'(.*)', file_name)[0]
@@ -126,49 +118,42 @@ class AtcfsApi:
         except IndexError:
             pass
         file_content = response.content
+
         return file_name, file_content
 
     def delete_file(self, ident):
-        """
-        Удаление файла на сервере ATCFS
+        """Удаление файла на сервере ATCFS.
+
         :param ident: идентификатор файла
         """
         url = self._build_url(settings.FILES_PATH, ident)
-        response = self._send_request(
-            method='delete',
-            url=url
-        )
+        response = self._send_request(method='delete', url=url)
         if response.status_code != 200:
             raise Exception(response.text)
 
     def get_file_url(self, ident):
-        """
-        Получить прямую ссылку на файл.
+        """Получить прямую ссылку на файл.
+
         :param ident: идентификатор файла
         :return: url
         """
         url = self._build_url(settings.TMP_FILE_LINK_PATH, ident)
-        response = self._send_request(
-            method='get',
-            url=url
-        )
+        response = self._send_request(method='get', url=url)
         if response.status_code != 200:
             raise Exception(response.text)
         tmp_ident = response.text
         file_url = self._build_url(settings.TMP_FILES_PATH, tmp_ident)
+
         return file_url
 
     def get_file_info(self, ident):
-        """
-        Получить информацию о файле.
+        """Получить информацию о файле.
+
         :param ident: идентификатор файла
         :return: словарь с названием файла и его размером
         """
         url = self._build_url(settings.FILE_INFO_PATH, ident)
-        response = self._send_request(
-            method='get',
-            url=url
-        )
+        response = self._send_request(method='get', url=url)
         if response.status_code != 200:
             raise Exception(response.text)
         file_json = response.json()
@@ -176,4 +161,5 @@ class AtcfsApi:
             'name': file_json['fileName'],
             'size': file_json['size'],
         }
+
         return file_info

educommon/django/storages/atcfs/app_meta.py

@@ -11,7 +11,7 @@ def register_urlpatterns():
         re_path(
             r'^atcfs_unavailable/$',
             TemplateView.as_view(template_name='atcfs_unavailable.html'),
-            name='atcfs_unavailable'
+            name='atcfs_unavailable',
         ),
     ]