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

2025-09-21 20:23:04 +03:00
parent a26c9107f2
commit c3e65700b1
3 changed files with 148 additions and 14 deletions
--- a/etpgrf/config.py
+++ b/etpgrf/config.py
@@ -92,6 +92,29 @@ STR_TO_SYMBOL_REPLACEMENTS = [
    ('~=', CHAR_AP),  # Приблизительно равно (≈)
 ]

+# === КОНСТАНТЫ ДЛЯ ЕДИНИЦ ИЗМЕРЕНИЯ ===
+# Пост-позиционные (10 км)
+DEFAULT_POST_UNITS = [
+    # Русские
+    'гг', 'г.', 'кг', 'мг', 'ц', 'т',
+    'кв.м', 'куб.м', 'мм', 'см', 'м', 'км', 'л', 'мл', 'сот', 'га',
+    'сек', 'с.', 'мин', 'ч',
+    'руб', 'коп',
+    'тыс', 'млн', 'млрд',
+    'пп', 'стр', 'рис', 'табл', 'гл', 'п', 'шт',
+    # Английские
+    'pp', 'p', 'para', 'sect', 'fig', 'vol', 'ed',
+]
+# Пред-позиционные (№ 5, $ 10)
+DEFAULT_PRE_UNITS = ['№', '$', '€', '£', '₽', '#']
+
+# === КОНСТАНТЫ ДЛЯ СЛОЖНЫХ (СОСТАВНЫХ) ЕДИНИЦ ИЗМЕРЕНИЯ ===
+# Эти единицы будут автоматически "склеены" неразрывными пробелами внутри LayoutProcessor
+DEFAULT_COMPLEX_UNITS = [
+    'до н. э.',
+    'н. э.',
+]
+
 # === КОНСТАНТЫ ДЛЯ КОДИРОВАНИЯ HTML-МНЕМНОИКОВ ===
 # --- ЧЕРНЫЙ СПИСОК: Символы, которые НИКОГДА не нужно кодировать в мнемоники ---
 NEVER_ENCODE_CHARS = (frozenset(['!', '#', '%', '(', ')', '*', ',', '.', '/', ':', ';', '=', '?', '@',
--- a/etpgrf/layout.py
+++ b/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