768_content_objects_3level

.env_example

@@ -1,5 +1,3 @@
-RECAPTCHA_SITE_KEY=123
-RECAPTCHA_SECRET_KEY=123
 SECRET_KEY=123
 ADMIN_PASSWORD=admin
 SIGNUP_PAGE_ENABLED=False

.github/workflows/build.yml

@@ -12,7 +12,7 @@ jobs:
       - name: Build system images (non-pulling)
         run: |
           # build base image
-          docker build -f Dockerfile_base -t dvivanov/dis-base:v0.3 .
+          docker build -f Dockerfile_base -t dvivanov/dis-base:v0.5 .
       - name: Build docker-compose
         run: |
           cp .env_example .env

.gitignore

@@ -3,6 +3,8 @@ __pycache__/
 
 .idea
 venv
+.venv
+.vscode
 *.pyc
 
 files/*
@@ -14,7 +16,5 @@ node_modules
 src/
 .env
 
-/VERSION.json
+VERSION.json
 
-app/main/mse22/converted_files/
-/app/main/mse22/for_testing/test/.pytest_cache/

README.md

@@ -3,8 +3,6 @@
 ## Environment
 - To `.env` in root:
 ```
-RECAPTCHA_SITE_KEY=...
-RECAPTCHA_SECRET_KEY=...
 SECRET_KEY=...
 ADMIN_PASSWORD=...
 SIGNUP_PAGE_ENABLED=...

app/main/check_packs/base_criterion_pack.py

@@ -18,7 +18,8 @@ def __init__(self, raw_criterions, file_type, min_score=1.0, name=None, **kwargs
 
     def init(self, file_info):
         # create criterion objects, ignore errors - validation was performed earlier
-        self.criterions, errors = init_criterions(self.raw_criterions, file_type=self.file_type, file_info=file_info)
+        file_info['file_type'] = self.file_type
+        self.criterions, errors = init_criterions(self.raw_criterions, file_info=file_info)
 
     def check(self):
         result = []

app/main/check_packs/pack_config.py

@@ -50,6 +50,7 @@
     ["empty_task_page_check"],
     ["water_in_the_text_check"],
     ["report_task_tracker"],
+    ["report_3_level_in_content_check"],
 ]
 
 DEFAULT_TYPE = 'pres'

app/main/check_packs/utils.py

@@ -6,11 +6,12 @@
 logger = getLogger('root_logger')
 
 
-def init_criterions(criterions, file_type, file_info={}):
+def init_criterions(criterions, file_info):
     """
     criterions = [[criterion_id, criterion_params], ...]  # criterion_params is dict
     """
     try:
+        file_type = file_info['file_type']
         existing_criterions = AVAILABLE_CHECKS.get(file_type['type'], {})
         errors = []
         initialized_checks = []

app/main/checks/base_check.py

@@ -13,14 +13,14 @@ def answer(mod, *args):
 class BaseCriterion:
     description = None
     label = None
-    file_type = None
     id = None
     priority = False  # if priority criterion is failed -> check is failed
 
     def __init__(self, file_info):
         self.file = file_info.get('file')
         self.filename = file_info.get('filename', '')
         self.pdf_id = file_info.get('pdf_id')
+        self.file_type = file_info.get('file_type')
 
     def check(self):
         raise NotImplementedError()
@@ -36,8 +36,8 @@ def name(self):
 
 
 class BasePresCriterion(BaseCriterion):
-    file_type = 'pres'
+    pass
 
 
 class BaseReportCriterion(BaseCriterion):
-    file_type = {'type': 'report', 'report_type': 'VKR'}
+    pass

app/main/checks/presentation_checks/__init__.py

@@ -17,3 +17,4 @@
 from .name_of_image_check import PresImageCaptureCheck
 from .task_tracker import TaskTracker
 from .overview_in_tasks import OverviewInTasks
+from .decimal_places import PresDecimalPlacesCheck

app/main/checks/presentation_checks/decimal_places.py

@@ -0,0 +1,16 @@
+from app.utils.decimal_places_check import DecimalPlacesCheck
+from ..base_check import BasePresCriterion, answer
+
+class PresDecimalPlacesCheck(BasePresCriterion):
+    label = 'Проверка на избыточное количество десятичных знаков'
+    description = 'Проверка на избыточное количество десятичных знаков в числах'
+    id = 'decimal_places_check'
+
+    def __init__(self, file_info, max_decimal_places=2, max_violations=3):
+        super().__init__(file_info)
+        self.checker = DecimalPlacesCheck(file_info, max_decimal_places, max_violations)
+
+    def check(self):    
+        total_violations, detected_pages = self.checker.find_violations_in_texts(enumerate(self.file.get_text_from_slides(), start=1))
+        result_str, result_score = self.checker.get_result_msg_and_score(total_violations, detected_pages, self.format_page_link)
+        return answer(result_score, result_str)

app/main/checks/presentation_checks/image_share.py

@@ -23,4 +23,3 @@ def check(self):
                                         ограничение - {round(self.limit, 2)}')
         else:
             return answer(True, f'Пройдена!')
-        return answer(False, 'Во время обработки произошла критическая ошибка')

app/main/checks/report_checks/__init__.py

@@ -34,3 +34,5 @@
 from .task_tracker import ReportTaskTracker
 from .paragraphs_count_check import ReportParagraphsCountCheck
 from .template_name import ReportTemplateNameCheck
+from .check_chapters_3_level import ReportСhaptersLevel3ContentCheck
+from .decimal_places import ReportDecimalPlacesCheck

app/main/checks/report_checks/banned_words_check.py

@@ -5,12 +5,13 @@
 
 class ReportBannedWordsCheck(BaseReportCriterion):
     label = "Проверка наличия запретных слов в тексте отчёта"
-    description = 'Запрещено упоминание слова "мы"'
+    description = 'Запрещено упоминание определенных "опасных" слов'
     id = 'banned_words_check'
 
     def __init__(self, file_info, headers_map=None):
         super().__init__(file_info)
         self.words = []
+        self.warned_words = []
         self.min_count = 0
         self.max_count = 0
         if headers_map:
@@ -21,42 +22,50 @@ def __init__(self, file_info, headers_map=None):
     def late_init(self):
         self.headers_main = self.file.get_main_headers(self.file_type['report_type'])
         if self.headers_main in StyleCheckSettings.CONFIGS.get(self.config):
-            self.words = [morph.normal_forms(word)[0] for word in StyleCheckSettings.CONFIGS.get(self.config)[self.headers_main]['banned_words']]
+            self.words = {morph.normal_forms(word)[0] for word in StyleCheckSettings.CONFIGS.get(self.config)[self.headers_main]['banned_words']}
+            self.warned_words = {morph.normal_forms(word)[0] for word in StyleCheckSettings.CONFIGS.get(self.config)[self.headers_main]['warned_words']}
             self.min_count = StyleCheckSettings.CONFIGS.get(self.config)[self.headers_main]['min_count_for_banned_words_check']
             self.max_count = StyleCheckSettings.CONFIGS.get(self.config)[self.headers_main]['max_count_for_banned_words_check']
         else:
             if 'any_header' in StyleCheckSettings.CONFIGS.get(self.config):
-                self.words = [morph.normal_forms(word)[0] for word in StyleCheckSettings.CONFIGS.get(self.config)['any_header']['banned_words']]
+                self.words = {morph.normal_forms(word)[0] for word in StyleCheckSettings.CONFIGS.get(self.config)['any_header']['banned_words']}
+                self.warned_words = {morph.normal_forms(word)[0] for word in StyleCheckSettings.CONFIGS.get(self.config)['any_header']['warned_words']}
                 self.min_count = StyleCheckSettings.CONFIGS.get(self.config)['any_header']['min_count_for_banned_words_check']
                 self.max_count = StyleCheckSettings.CONFIGS.get(self.config)['any_header']['max_count_for_banned_words_check']
 
     def check(self):
         if self.file.page_counter() < 4:
             return answer(False, "В отчете недостаточно страниц. Нечего проверять.")
         self.late_init()
-        detected_lines = {}
         result_str = f'<b>Запрещенные слова: {"; ".join(self.words)}</b><br>'
-        count = 0
+        banned_counter = {'words': self.words, 'detected_lines': {}, 'count': 0}
+        warned_counter = {'words': self.warned_words,'detected_lines': {}, 'count': 0}
         for k, v in self.file.pdf_file.get_text_on_page().items():
             lines_on_page = re.split(r'\n', v)
             for index, line in enumerate(lines_on_page):
-                words_on_line = re.split(r'[^\w-]+', line)
-                words_on_line = [morph.normal_forms(word)[0] for word in words_on_line]
-                count_banned_words = set(words_on_line).intersection(self.words)
-                if count_banned_words:
-                    count += len(count_banned_words)
-                    if k not in detected_lines.keys():
-                        detected_lines[k] = []
-                    detected_lines[k].append(f'Строка {index + 1}: {line} <b>[{"; ".join(count_banned_words)}]</b>')
-        if len(detected_lines):
+                words_on_line = {morph.normal_forms(word)[0] for word in re.split(r'[^\w-]+', line)}
+                for counter in (banned_counter, warned_counter):
+                    count_banned_words = words_on_line.intersection(counter['words'])
+                    if count_banned_words:
+                        counter['count'] += len(count_banned_words)
+                        if k not in counter['detected_lines'].keys():
+                            counter['detected_lines'][k] = []
+                        counter['detected_lines'][k].append(f'Строка {index + 1}: {line} <b>[{"; ".join(count_banned_words)}]</b>')
+        if len(banned_counter['detected_lines']):
             result_str += 'Обнаружены запретные слова! <br><br>'
-            for k, v in detected_lines.items():
-                result_str += f'Страница №{k}:<br>{"<br>".join(detected_lines[k])}<br><br>'
+            for k, v in banned_counter['detected_lines'].items():
+                result_str += f'Страница №{k}:<br>{"<br>".join(banned_counter['detected_lines'][k])}<br><br>'
         else:
             result_str = 'Пройдена!'
+
+        if len(warned_counter['detected_lines']):
+            result_str += f'<br><br>Обнаружены потенциально опасные слова (не влияют на результат проверки)!<br>Обратите внимание, что их использование возможно только в подтвержденных случаях: {"; ".join(self.warned_words)}<br><br>'
+            for k, v in warned_counter['detected_lines'].items():
+                result_str += f'Страница №{k}:<br>{"<br>".join(warned_counter['detected_lines'][k])}<br><br>'
+
         result_score = 1
-        if count > self.min_count:
-            if count <= self.max_count:
+        if banned_counter['count'] > self.min_count:
+            if banned_counter['count'] <= self.max_count:
                 result_score = 0.5
             else:
                 result_score = 0

app/main/checks/report_checks/banned_words_in_literature.py

@@ -27,6 +27,7 @@ def check(self):
         if self.file.page_counter() < 4:
             return answer(False, "В отчете недостаточно страниц. Нечего проверять.")
         detected_words_dict = {}
+        # TODO: проверить совместимость / дублируемость LR и VKR
         if self.file_type['report_type'] == 'LR':
             list_of_literature = self.find_literature()
             if len(list_of_literature) == 0:
@@ -51,7 +52,7 @@ def check(self):
                         else:
                             detected_words_dict[child_number] = banned_word
         else:
-            return answer(False, 'Во время обработки произошла критическая ошибка')
+            return answer(False, 'Во время обработки произошла критическая ошибка - указан неверный тип работы в наборе критериев')
         if detected_words_dict:
             result_str = ""
             for i in sorted(detected_words_dict.keys()):

app/main/checks/report_checks/chapters.py

@@ -13,7 +13,7 @@ class ReportChapters(BaseReportCriterion):
     def __init__(self, file_info):
         super().__init__(file_info)
         self.headers = []
-        self.target_styles = StyleCheckSettings.VKR_CONFIG
+        self.target_styles = StyleCheckSettings.VKR_CONFIG if (self.file_type['report_type'] == 'VKR') else StyleCheckSettings.LR_CONFIG
         self.target_styles = list(map(lambda elem: {
             "style": self.construct_style_from_description(elem["style"])
         }, self.target_styles.values()))
@@ -29,7 +29,7 @@ def __init__(self, file_info):
             level += 1
 
     def late_init(self):
-        self.headers = self.file.make_chapters(self.file_type['report_type'])
+        self.headers = self.file.make_chapters()#self.file_type['report_type'])
 
     @staticmethod
     def construct_style_from_description(style_dict):
@@ -57,38 +57,35 @@ def check(self):
             return answer(False, "В отчете недостаточно страниц. Нечего проверять.")
         self.late_init()
         result_str = ''
-        if self.file_type['report_type'] == 'VKR':
-            if not len(self.headers):
-                return answer(False, "Не найдено ни одного заголовка.<br><br>Проверьте корректность использования стилей.")
-            for header in self.headers:
-                marked_style = 0
-                for key in self.docx_styles.keys():
-                    if not marked_style:
-                        for style_name in self.docx_styles[key]:
-                            if header["style"].find(style_name) >= 0:
-                                if self.style_regex[key].match(header["text"]):
-                                    marked_style = 1
-                                    err = self.style_diff(header["styled_text"], self.target_styles[key]["style"])
-                                    err = list(map(lambda msg: f'Стиль "{header["style"]}": ' + msg, err))
-                                    result_str += ("<br>".join(err) + "<br>" if len(err) else "")
-                                    break
+        if not len(self.headers):
+            return answer(False, "Не найдено ни одного заголовка.<br><br>Проверьте корректность использования стилей.")
+        for header in self.headers:
+            marked_style = 0
+            for key in self.docx_styles.keys():
                 if not marked_style:
-                    err = f"Заголовок \"{header['text']}\": "
-                    err += f'Стиль "{header["style"]}" не соответстует ни одному из стилей заголовков.'
-                    result_str += (str(err) + "<br>")
+                    for style_name in self.docx_styles[key]:
+                        if header["style"].find(style_name) >= 0:
+                            if self.style_regex[key].match(header["text"]):
+                                marked_style = 1
+                                err = self.style_diff(header["styled_text"], self.target_styles[key]["style"])
+                                err = list(map(lambda msg: f'Стиль "{header["style"]}": ' + msg, err))
+                                result_str += ("<br>".join(err) + "<br>" if len(err) else "")
+                                break
+            if not marked_style:
+                err = f"Заголовок \"{header['text']}\": "
+                err += f'Стиль "{header["style"]}" не соответствует ни одному из стилей заголовков.'
+                result_str += (str(err) + "<br>")
 
-            if not result_str:
-                return answer(True, "Форматирование заголовков соответствует требованиям.")
-            else:
-                result_string = f'Найдены ошибки в оформлении заголовков:<br>{result_str}<br>'
-                result_string += '''
-                                        Попробуйте сделать следующее:
-                                        <ul>
-                                            <li>Убедитесь в соответствии стиля заголовка требованиям к отчету по ВКР;</li>
-                                            <li>Убедитесь, что названия разделов и нумированные разделы оформлены по ГОСТу;</li>
-                                            <li>Убедитесь, что красная строка не сделана с помощью пробелов или табуляции.</li>
-                                        </ul>
-                                        '''
-                return answer(False, result_string)
+        if not result_str:
+            return answer(True, "Форматирование заголовков соответствует требованиям.")
         else:
-            return answer(False, 'Во время обработки произошла критическая ошибка')
+            result_string = f'Найдены ошибки в оформлении заголовков:<br>{result_str}<br>'
+            result_string += '''
+                                    Попробуйте сделать следующее:
+                                    <ul>
+                                        <li>Убедитесь в соответствии стиля заголовка требованиям к отчету по ВКР;</li>
+                                        <li>Убедитесь, что названия разделов и нумированные разделы оформлены по ГОСТу;</li>
+                                        <li>Убедитесь, что красная строка не сделана с помощью пробелов или табуляции.</li>
+                                    </ul>
+                                    '''
+            return answer(False, result_string)

app/main/checks/report_checks/check_chapters_3_level.py

@@ -0,0 +1,51 @@
+from ..base_check import BaseReportCriterion, answer
+
+class ReportСhaptersLevel3ContentCheck(BaseReportCriterion):
+    label = "Проверка содержания на наличия объктов 3 уровня"
+    description = "В содержании не должно быть объектов третьего уровня"
+    id = 'report_3_level_in_content_check'
+
+    def __init__(self, file_info):
+        super().__init__(file_info)
+
+
+    def check(self):
+        try:           
+            headers = self.file.make_chapters(self.file_type['report_type'])
+
+            if not headers:
+                return answer(False, "Не найдено ни одного заголовка.")
+
+            level_3_count = 0
+            bool_content_find = False
+            for header in headers:
+                if header["text"].upper() == "СОДЕРЖАНИЕ":
+                    bool_content_find = True
+                    level_3_count = self._count_level_3_headers(header["child"])
+                    break
+
+            if not bool_content_find:
+                return answer(False, "Не найдено заголовка 'Содержание'")
+
+            if level_3_count > 0:
+                result_str = f"Найдено {level_3_count} заголовков 3 уровня и выше. "
+                result_str += "Содержание должно содержать только заголовки 1 и 2 уровня.<br>"
+                return answer(False, result_str)
+
+            return answer(True, "Все заголовки соответствуют требованиям (1-2 уровень)")
+
+        except Exception as e:
+            return answer(False, f"Ошибка при проверке: {str(e)}")
+
+    def _count_level_3_headers(self, content):
+        count = 0
+
+        for header in content:
+            if self._is_level_3_or_higher(header):
+                count += 1
+                count += self._count_level_3_headers(header["child"])
+
+        return count
+
+    def _is_level_3_or_higher(self, header):
+        return header["level"] >= 3