add: LayoutProcessor - обработка едениц измерения (draft)

etpgrf/layout.py

@@ -3,7 +3,8 @@
 
 import regex
 import logging
-from etpgrf.config import LANG_RU, LANG_EN, CHAR_NBSP, CHAR_THIN_SP, CHAR_NDASH, CHAR_MDASH, CHAR_HELLIP
+from etpgrf.config import (LANG_RU, LANG_EN, CHAR_NBSP, CHAR_THIN_SP, CHAR_NDASH, CHAR_MDASH, CHAR_HELLIP,
+                           DEFAULT_POST_UNITS, DEFAULT_PRE_UNITS, DEFAULT_COMPLEX_UNITS)
 from etpgrf.comutil import parse_and_validate_langs
 
 # --
@@ -23,14 +24,16 @@ class LayoutProcessor:
 
     def __init__(self,
                  langs: str | list[str] | tuple[str, ...] | frozenset[str] | None = None,
-                 process_initials_and_acronyms: bool = True):
+                 process_initials_and_acronyms: bool = True,
+                 process_units: bool | str | list[str] = True,
+                 process_complex_units: bool | list[str] = True):
+
         self.langs = parse_and_validate_langs(langs)
         self.main_lang = self.langs[0] if self.langs else LANG_RU
         self.process_initials_and_acronyms = process_initials_and_acronyms
-
+        self.process_units = process_units
+        self.process_complex_units = process_complex_units
         # 1. Паттерн для длинного (—) или среднего (–) тире, окруженного пробелами.
-        # (?<=\S) и (?=\S) гарантируют, что тире находится между словами, а не в начале/конце строки.
-        # self._dash_pattern = regex.compile(rf'(?<=\S)\s+([{CHAR_MDASH}{CHAR_NDASH}])\s+(?=\S)')
         # (?<=[\p{L}\p{Po}\p{Pf}"\']) - просмотр назад на букву, пунктуацию или кавычку.
         self._dash_pattern = regex.compile(rf'(?<=[\p{{L}}\p{{Po}}\p{{Pf}}"\'])\s+([{CHAR_MDASH}{CHAR_NDASH}])\s+(?=\S)')
 
@@ -59,11 +62,59 @@ class LayoutProcessor:
         self._initial_to_initial_ns_pattern = regex.compile(r'(\p{Lu}\.)(?=\p{Lu}\.)')
         self._initial_to_surname_ns_pattern = regex.compile(r'(\p{Lu}\.)(?=\p{Lu}\p{L}{1,})')
 
+        # 5. Паттерны для единиц измерения.
+        self._post_units_pattern = None
+        self._pre_units_pattern = None
+        if self.process_units:
+            post_units = list(DEFAULT_POST_UNITS)
+            pre_units = list(DEFAULT_PRE_UNITS)
+            # Проверяем и добавляем пользовательские единицы измерения
+            custom_units = []
+
+            # Обработка составных единиц: "склеиваем" их тонкой шпацией и добавляем в общий список
+            if self.process_complex_units:
+                complex_units_to_process = list(DEFAULT_COMPLEX_UNITS)
+                if isinstance(self.process_complex_units, (list, tuple, set)):
+                    complex_units_to_process.extend(self.process_complex_units)
+
+                # "Склеиваем" пробелы внутри составных единиц и добавляем в общий список
+                post_units.extend([unit.replace(' ', CHAR_THIN_SP) for unit in complex_units_to_process])
+
+            if isinstance(self.process_units, str):
+                # Если кастомные единицы заданы строкой, разбиваем по пробелам
+                custom_units = self.process_units.split()
+            elif isinstance(self.process_units, (list, tuple, set)):
+                # Если кастомные единицы заданы списком/кортежем/множеством, просто конвертируем в список
+                custom_units = list(self.process_units)
+
+            if custom_units:
+                post_units.extend(custom_units)
+
+            if post_units:
+                # [\d.,]+ - число, возможно, с точкой или запятой
+                # Используем негативный просмотр вперед (?!), чтобы убедиться, что за единицей
+                # не следует другая буква. Это надежнее, чем \b, особенно для единиц,
+                # оканчивающихся на точку (например, "г.").
+                post_pattern_str = r'(\d[\d.,]*)\s+(' + '|'.join(regex.escape(u) for u in post_units) + r')(?![\p{L}\p{N}])'
+                self._post_units_pattern = regex.compile(post_pattern_str)
+
+            if pre_units:
+                # Используем негативный просмотр назад (?<!), чтобы убедиться, что перед единицей
+                # нет буквы. \b здесь не работает для символов типа "№" или "$".
+                pre_pattern_str = r'(?<![\p{L}\p{N}])(' + '|'.join(regex.escape(u) for u in pre_units) + r')\s+(\d[\d.,]*)'
+                self._pre_units_pattern = regex.compile(pre_pattern_str)
+
+        # 6. Паттерн для связи единиц-умножителей (тыс., млн.) со следующей единицей.
+        # Ищет умножитель, за которым может быть точка, а затем пробел.
+        multiplier_units = ['тыс', 'млн', 'млрд']
+        self._unit_multiplier_pattern = regex.compile(r'((' + '|'.join(multiplier_units) + r')\.?)\s+')
+
         logger.debug(f"LayoutProcessor `__init__`. "
                      f"Langs: {self.langs}, "
                      f"Main lang: {self.main_lang}, "
-                     f"Process initials and acronyms: {self.process_initials_and_acronyms}")
-
+                     f"Process initials and acronyms: {self.process_initials_and_acronyms}, "
+                     f"Process units: {bool(self.process_units)}, "
+                     f"Process complex units: {bool(self.process_complex_units)}")
 
     def _replace_dash_spacing(self, match: regex.Match) -> str:
         """Callback-функция для расстановки пробелов вокруг тире с учетом языка."""
@@ -100,4 +151,16 @@ class LayoutProcessor:
              processed_text = self._initial_to_surname_ws_pattern.sub(f'\\1{CHAR_NBSP}', processed_text)
              processed_text = self._surname_to_initial_ws_pattern.sub(f'\\1{CHAR_NBSP}', processed_text)
 
+         # 5. Обработка единиц измерения (если включено).
+         if self.process_units and self._unit_multiplier_pattern:
+             processed_text = self._unit_multiplier_pattern.sub(r'\1' + CHAR_NBSP, processed_text)
+
+         # 6. Обработка единиц измерения (простых и составных).
+         if self.process_units:
+             if self._post_units_pattern:
+                 processed_text = self._post_units_pattern.sub(f'\\1{CHAR_NBSP}\\2', processed_text)
+             if self._pre_units_pattern:
+                 processed_text = self._pre_units_pattern.sub(f'\\1{CHAR_NBSP}\\2', processed_text)
+
+
          return processed_text