cdc-1c 0.1.0__py3-none-any.whl

cdc_1c/__init__.py

@@ -0,0 +1,18 @@
+from importlib.metadata import version, PackageNotFoundError
+
+try:
+    __version__ = version("cdc-1c")
+except PackageNotFoundError:
+    __version__ = "dev"
+
+from .metadata_reader import MetadataReader1C
+from .data_reader import DataReader1C, DataObject1C
+from .change_reader import ChangeReader1C
+from .name_mapper import NameMapper1C
+from .db_writer import DBWriter1C
+from .config import Config
+from .replicator import Replicator1C
+
+__all__ = ["MetadataReader1C", "DataReader1C", "DataObject1C", "ChangeReader1C", "NameMapper1C",
+           "DBWriter1C", "Config", "Replicator1C", "__version__"]
+

cdc_1c/__main__.py

@@ -0,0 +1,30 @@
+"""
+Entrypoint для запуска из окружения: `python -m cdc_1c` или команда `cdc-1c`.
+
+Настройки читаются из переменных окружения CDC1C_* (см. Config.from_env), из них строится
+Replicator1C. Режим — CDC1C_MODE: `loop` (по умолчанию) запускает run_forever с периодом
+CDC1C_POLL_INTERVAL, `once` — один run_once.
+"""
+import logging
+
+from cdc_1c.config import Config
+from cdc_1c.replicator import Replicator1C
+
+
+def main() -> None:
+    config = Config.from_env()
+    replicator = Replicator1C.from_config(config)
+    # Уровень логирования из конфига — после конструктора: он вешает обработчик на логгер cdc_1c
+    # (по умолчанию INFO), а тут переопределяем на заданный (например, DEBUG/WARNING).
+    logging.getLogger("cdc_1c").setLevel(config.log_level.upper())
+
+    if config.mode == "once":
+        replicator.run_once()
+    elif config.mode == "loop":
+        replicator.run_forever(interval=config.poll_interval)
+    else:
+        raise SystemExit(f"Unknown CDC1C_MODE={config.mode!r} (expected 'loop' or 'once')")
+
+
+if __name__ == "__main__":
+    main()

cdc_1c/change_reader.py

@@ -0,0 +1,77 @@
+import requests
+import logging
+
+import xmltodict
+
+from cdc_1c.data_reader import DataReader1C
+from cdc_1c.metadata_reader import MetadataReader1C, resolve_timeout
+
+logger = logging.getLogger(__name__)
+
+
+class ChangeReader1C(DataReader1C):
+    def __init__(self, odata_url: str, exchange_name: str, queue_guid: str,
+                 metadata: MetadataReader1C, odata_auth: tuple[str, str] | None = None,
+                 request_timeout: float | None = None):
+        super().__init__(odata_url, metadata, odata_auth, request_timeout)
+        self.exchange_name = exchange_name
+        self.queue_guid = queue_guid
+        self.message_no = 0
+
+    def read_changes(self):
+        # Сбрасываем накопленные данные предыдущего цикла (важно для run_forever).
+        self.clear()
+        self.message_no = self.get_last_received_no()+1
+        self.exchange_message_no = self.message_no
+
+        logger.info(f"Reading changes from 1C (message {self.message_no})")
+
+        url = f"{self.odata_url}/SelectChanges?DataExchangePoint='{self.odata_url}/ExchangePlan_{self.exchange_name}(guid'{self.queue_guid}')'&MessageNo={self.message_no}"
+
+        response = requests.post(url,auth=self.odata_auth,timeout=resolve_timeout(self.request_timeout))
+        response.raise_for_status()
+
+        change_data = xmltodict.parse(response.text,force_list=('d:element','entry'))
+        change_entries = (change_data.get('feed') or {}).get('entry') or []
+
+        self.read_data_entries(change_entries)
+
+    def notify_changes_received(self):
+        """
+        Подтвердить получение изменений, отправив запрос на сервер
+        """
+        url = f"{self.odata_url}/NotifyChangesReceived?DataExchangePoint='{self.odata_url}/ExchangePlan_{self.exchange_name}(guid'{self.queue_guid}')'&MessageNo={self.message_no}"
+        response = requests.post(url,auth=self.odata_auth,timeout=resolve_timeout(self.request_timeout))
+        # Не-2xx -> HTTPError. Подтверждение не прошло — изменения не списаны и придут снова
+        # (в run_forever цикл повторится, save идемпотентен).
+        response.raise_for_status()
+        logger.info(f"Changes confirmed for queue {self.queue_guid} (message {self.message_no})")
+
+
+    def get_last_received_no(self)->int:
+        """
+        Получить номер последнего пакета обмена, который был получен и подтвержден
+        """
+        url = f"{self.odata_url}/ExchangePlan_{self.exchange_name}?$format=json"
+        response = requests.get(url,auth=self.odata_auth,timeout=resolve_timeout(self.request_timeout))
+        response.raise_for_status()
+        queues_data = response.json()
+
+        queues = queues_data.get('value') or []
+        receive_no = 0
+        found = False
+
+        for queue in queues:
+            if self.queue_guid == queue['Ref_Key']:
+                receive_no = int(queue['ReceivedNo'])
+                found = True
+
+        if not found:
+            # Очередь по guid не нашлась — вернём 0 (запросится пакет №1), но это почти наверняка
+            # неверный queue_guid или план обмена: без предупреждения ошибку конфигурации не видно.
+            logger.warning("Exchange queue %s not found in plan %s (check queue_guid/exchange_name)",
+                           self.queue_guid, self.exchange_name)
+
+        return receive_no
+    
+

cdc_1c/common_functions.py

@@ -0,0 +1,30 @@
+import logging
+
+ODATA_PREFIX = 'StandardODATA.'
+
+logger = logging.getLogger(__name__)
+
+def parse_object_full_name(object_full_name):
+    """
+    Очищаем имя объекта от разных префиксов, постфиксов и скобок.
+    Возвращает очищенное имя и тип объекта
+    """
+    if object_full_name is None:
+        logger.error(f'Object full name is None')
+        return None, None
+
+    object_name = object_full_name
+
+    if object_name.startswith('Collection'):
+        object_name = object_name.removeprefix('Collection(')
+        object_name = object_name.removesuffix(')')
+
+    object_name = object_name.removeprefix(ODATA_PREFIX)
+    object_name = object_name.removesuffix('_RowType')
+
+    if '_' in object_name:
+        object_type = object_name.split('_')[0]
+    else:
+        logger.error(f'Object type not found in object full name {object_full_name}')
+        return None, None
+    return object_name, object_type

cdc_1c/config.py

@@ -0,0 +1,41 @@
+import os
+from dataclasses import dataclass
+
+
+@dataclass
+class Config:
+    """
+    Настройки оркестратора. Ядро не зависит от окружения: Config заполняется явно (библиотечный
+    сценарий) либо через from_env() (entrypoint контейнера). Строку подключения к БД (db_url)
+    в engine превращает Replicator1C.from_config.
+    """
+
+    odata_url: str
+    odata_user: str | None
+    odata_password: str | None
+    exchange_name: str
+    queue_guid: str
+    db_url: str
+    db_schema: str | None = None
+    log_level: str = "INFO"
+    full_load_workers: int = 2
+    # Параметры цикла для entrypoint (python -m cdc_1c): режим и период опроса run_forever.
+    mode: str = "loop"          # loop → run_forever, once → один run_once
+    poll_interval: float = 60.0
+
+    @classmethod
+    def from_env(cls) -> "Config":
+        """Читает настройки из переменных окружения CDC1C_* (используется только entrypoint-ом)."""
+        return cls(
+            odata_url=os.environ["CDC1C_ODATA_URL"],
+            odata_user=os.environ.get("CDC1C_ODATA_USER"),
+            odata_password=os.environ.get("CDC1C_ODATA_PASSWORD"),
+            exchange_name=os.environ["CDC1C_EXCHANGE_NAME"],
+            queue_guid=os.environ["CDC1C_QUEUE_GUID"],
+            db_url=os.environ["CDC1C_DB_URL"],
+            db_schema=os.environ.get("CDC1C_DB_SCHEMA"),
+            log_level=os.environ.get("CDC1C_LOG_LEVEL", "INFO"),
+            full_load_workers=int(os.environ.get("CDC1C_FULL_LOAD_WORKERS", "2")),
+            mode=os.environ.get("CDC1C_MODE", "loop"),
+            poll_interval=float(os.environ.get("CDC1C_POLL_INTERVAL", "60")),
+        )

cdc_1c/data_reader.py

@@ -0,0 +1,452 @@
+from __future__ import annotations
+
+import requests
+import logging
+from typing import Any
+from collections import UserDict
+from datetime import datetime, date
+from urllib.parse import quote
+import uuid
+
+import xmltodict
+
+from cdc_1c.metadata_reader import MetadataReader1C, resolve_timeout
+from cdc_1c.name_mapper import NameMapper1C
+from cdc_1c.common_functions import parse_object_full_name
+
+logger = logging.getLogger(__name__)
+
+
+def _json_safe(value: Any) -> Any:
+    """Приводит значение к JSON-сериализуемому виду: UUID -> str, datetime/date -> ISO."""
+    if isinstance(value, uuid.UUID):
+        return str(value)
+    if isinstance(value, (datetime, date)):
+        return value.isoformat()
+    return value
+
+REGISTER_TYPES = ('InformationRegister','AccumulationRegister')
+ENTITY_TYPES = ('Catalog','Document')
+METADATA_POSTFIXES = ('_RecordType','_RowType','_Balance','_Turnover','_BalanceAndTurnover')
+ODATA_PREFIX = 'StandardODATA.'
+
+# Поле 1С с пометкой удаления у документов и справочников.
+DELETION_MARK_FIELD = 'DeletionMark'
+# Спец-поле, заполняемое при загрузке: True для удаленных объектов (DeletionMark)
+# и для фиктивных записей (удаленный набор регистра, опустевшая табличная часть).
+IS_DELETED_OR_EMPTY_FIELD = 'is_deleted_or_empty'
+# Спец-поле: номер пакета обмена (message_no), проставляется во все записи при чтении изменений.
+EXCHANGE_MESSAGE_NO_FIELD = 'exchange_message_no'
+
+
+def _odata_literal(value: Any, type_name: str) -> str:
+    """
+    OData-литерал значения по типу поля (для keyset-фильтра): Guid → guid'…', DateTime → datetime'…',
+    числа — как есть, Boolean → true/false, остальное (String и пр.) — строка в кавычках (кавычка
+    внутри экранируется удвоением). value приходит уже сконвертированным (_convert_value): UUID/datetime.
+    """
+    if type_name == 'Guid':
+        return f"guid'{value}'"
+    if type_name == 'DateTime':
+        v = value.strftime('%Y-%m-%dT%H:%M:%S') if isinstance(value, (datetime, date)) else str(value)
+        return f"datetime'{v}'"
+    if type_name in ('Int64', 'Int16', 'Double'):
+        return str(value)
+    if type_name == 'Boolean':
+        return 'true' if value else 'false'
+    return "'" + str(value).replace("'", "''") + "'"
+
+
+def _keyset_filter(key_fields: list[str], after_values: list, key_types: list[str]) -> str:
+    """
+    Лексикографический keyset-фильтр «строка ключа > последней строки предыдущей страницы» для
+    составного ключа (key_fields, порядок = порядок $orderby):
+        (k1 gt v1) or (k1 eq v1 and k2 gt v2) or (k1 eq v1 and k2 eq v2 and k3 gt v3) ...
+    Для одиночного ключа сводится к «k1 gt v1». Литералы — по типам key_types (_odata_literal).
+    """
+    terms = []
+    for i in range(len(key_fields)):
+        conj = [f"{key_fields[j]} eq {_odata_literal(after_values[j], key_types[j])}" for j in range(i)]
+        conj.append(f"{key_fields[i]} gt {_odata_literal(after_values[i], key_types[i])}")
+        terms.append(" and ".join(conj))
+    return " or ".join(f"({t})" if " and " in t else t for t in terms)
+
+
+class DataObject1C(UserDict):
+    def __init__(self, metadata_obj=None, records: list = []):
+        super().__init__()
+        self.metadata_obj = metadata_obj  # MetadataObject1C
+        # Табличные части этого объекта: {имя_части: DataObject1C}. Заполняются при чтении
+        # (_get_entity_records связывает владельца с его ТЧ), используются to_nested_records.
+        self.table_parts: dict[str, DataObject1C] = {}
+        self.data_length = 0
+        self.add_records(records)
+
+    def add_records(self, records: list):
+        for record in records:
+            for k,v in record.items():
+                if k not in self.data.keys():
+                    # встретилось новое поле, нужно добавить его во все записи, которые уже есть.
+                    if self.data_length > 0:
+                        self.data[k] = [None] * self.data_length
+                    else:
+                        self.data[k] = []
+                self.data[k].append(v)
+
+            for k in self.data.keys():
+                 # если в новой записи нет какого-то поля, которое уже есть в данных, то нужно добавить это поле со значением None
+                if k not in record.keys():
+                    self.data[k].append(None)
+
+            self.data_length += 1
+
+    def to_records_mapped(self, column_mapping: dict[str, str] | None = None,
+                          json_safe: bool = False) -> list[dict]:
+        """
+        Преобразует колоночное хранилище (dict of lists) в список записей (list of dict)
+        для передачи в dbmerge. Если задан column_mapping, имена колонок заменяются на лету,
+        без отдельной переименованной копии данных (значения колонок переиспользуются по ссылке).
+
+        json_safe=True приводит значения к JSON-сериализуемому виду (UUID->str, datetime->ISO) —
+        для экспорта в JSON; по умолчанию False, чтобы dbmerge получал исходные типы.
+        """
+        keys = list(self.data.keys())
+        out_keys = [column_mapping.get(k, k) for k in keys] if column_mapping else keys
+        cols = list(self.data.values())
+        if json_safe:
+            return [dict(zip(out_keys, (_json_safe(v) for v in row))) for row in zip(*cols)]
+        return [dict(zip(out_keys, row)) for row in zip(*cols)]
+
+    def group_by(self, key_field: str = 'Ref_Key', name_mapper: NameMapper1C | None = None,
+                 json_safe: bool = False, skip_deleted: bool = False) -> dict[Any, list[dict]]:
+        """
+        Группирует записи объекта в {значение key_field: [записи]} одним проходом (hash group-by).
+        Записи — как в to_records_mapped (с маппингом/json_safe). Индекс не хранится в объекте, а
+        строится на вызов: платим только при экспорте, без накладных в add_records и без устаревания.
+
+        skip_deleted=True пропускает записи с is_deleted_or_empty (удалённые/фиктивные строки) —
+        для вложенных табличных частей: опустевшая ТЧ приходит фиктивной записью и должна дать
+        пустой список, а не группу с записью-пустышкой.
+        """
+        col_map = name_mapper.get_column_mapping(list(self.data.keys())) if name_mapper else None
+        key = name_mapper.map_field_name(key_field) if name_mapper else key_field
+        del_key = (name_mapper.map_field_name(IS_DELETED_OR_EMPTY_FIELD)
+                   if name_mapper else IS_DELETED_OR_EMPTY_FIELD)
+        grouped: dict[Any, list[dict]] = {}
+        for row in self.to_records_mapped(col_map, json_safe=json_safe):
+            if skip_deleted and row.get(del_key):
+                continue
+            grouped.setdefault(row.get(key), []).append(row)
+        return grouped
+
+    def to_nested_records(self, name_mapper: NameMapper1C | None = None,
+                          json_safe: bool = False) -> list[dict]:
+        """
+        Записи этого объекта (list of dict) с вложенными табличными частями — например, чтобы
+        отправить во внешний приёмник (RabbitMQ и т.п.) вместо записи в БД.
+
+        Табличные части берутся из self.table_parts (их связал контейнер при чтении), кладутся
+        вложенным списком под ключом = имя части, строки группируются по Ref_Key (group_by).
+
+        name_mapper=None → имена полей/частей как в 1С; передан — транслитерируем (как в БД).
+        json_safe=True → значения JSON-сериализуемы (UUID->str, datetime->ISO), готово к json.dumps.
+        """
+        col_map = name_mapper.get_column_mapping(list(self.data.keys())) if name_mapper else None
+        key = name_mapper.map_field_name('Ref_Key') if name_mapper else 'Ref_Key'
+        records = self.to_records_mapped(col_map, json_safe=json_safe)
+
+        for part_name, part_obj in self.table_parts.items():
+            part_key = name_mapper.map_field_name(part_name) if name_mapper else part_name
+            grouped = part_obj.group_by('Ref_Key', name_mapper, json_safe, skip_deleted=True)
+            for rec in records:
+                rec[part_key] = grouped.get(rec.get(key), [])
+        return records
+            
+
+
+class DataReader1C(UserDict):
+    def __init__(self, odata_url: str, metadata: MetadataReader1C,
+                 odata_auth: tuple[str, str] | None = None,
+                 request_timeout: float | None = None):
+        super().__init__()
+        self.odata_url = odata_url
+        self.metadata = metadata
+        self.odata_auth = odata_auth
+        self.request_timeout = request_timeout
+        self.exchange_message_no = None  # номер пакета обмена, проставляется в записи при чтении изменений
+
+    def read_object(self, object_name: str, top: int | None = None,
+                    key_fields: list[str] | None = None, after_values: list | None = None,
+                    key_types: list[str] | None = None, extra_filter: str | None = None) -> int:
+        """
+        Читает объект 1С в reader (предыдущее содержимое очищается). Постраничная выгрузка —
+        keyset-пагинация по составному ключу key_fields: сортировка по ключу ($orderby), лимит $top,
+        а следующая страница берётся лексикографическим фильтром «ключ больше последней строки
+        предыдущей страницы» (after_values). В отличие от $skip это не заставляет 1С перечитывать
+        пропущенные строки — каждая страница читается за один проход по индексу.
+
+        key_fields/key_types (порядок = порядок сортировки; типы — для литералов, см. _odata_literal):
+        - справочник/документ: ['Ref_Key'] / ['Guid'] (Ref_Key gt guid'...');
+        - регистраторный регистр: ['Recorder'] / ['String'] — в OData Recorder отдаётся строкой,
+          одна entry = целый набор записей регистратора, поэтому keyset по Recorder не рвёт набор;
+        - независимый регистр (нет Ref_Key/Recorder): весь первичный ключ (Period + измерения) —
+          составной keyset, т.к. одиночного уникального курсора нет.
+
+        extra_filter — дополнительный OData-фрагмент $filter (например, диапазон по дате), который
+        объединяется с keyset-условием по AND (составной keyset содержит OR — оборачиваем в скобки).
+
+        Возвращает число прочитанных записей верхнего уровня (entry) — по нему вызывающий понимает,
+        что страница последняя (меньше top).
+        """
+        key_fields = key_fields or ['Ref_Key']
+        key_types = key_types or ['Guid'] * len(key_fields)
+        params = []
+        if top is not None:
+            params.append(f"$top={top}")
+        params.append("$orderby=" + ','.join(key_fields))
+        # keyset-курсор и extra_filter объединяем по AND в один $filter.
+        filters = []
+        if after_values is not None:
+            keyset = _keyset_filter(key_fields, after_values, key_types)
+            # составной keyset содержит верхнеуровневый OR — оборачиваем в скобки, чтобы AND с
+            # extra_filter не исказил приоритет; одиночный ключ (без OR) оставляем как есть.
+            filters.append(f"({keyset})" if ' or ' in keyset else keyset)
+        if extra_filter:
+            filters.append(extra_filter)
+        if filters:
+            # URL собираем строкой — кодируем пробелы сами (requests строку не кодирует); двоеточия
+            # в datetime-литералах оставляем как есть (safe).
+            params.append("$filter=" + quote(" and ".join(filters), safe="':"))
+        query = '?' + '&'.join(params)
+        url = f"{self.odata_url}/{object_name}{query}"
+        response = requests.get(url, auth=self.odata_auth, timeout=resolve_timeout(self.request_timeout))
+        response.raise_for_status()
+
+        object_data = xmltodict.parse(response.text, force_list=('d:element', 'entry'))
+        object_entries = (object_data.get('feed') or {}).get('entry') or []
+
+        self.clear()
+        self.read_data_entries(object_entries)
+        return len(object_entries)
+
+    def read_data_entries(self, object_entries: list):
+        for object_entry in object_entries:
+
+            object_full_name = (object_entry.get('category') or {}).get('@term')
+            object_name, object_type = parse_object_full_name(object_full_name)
+
+            logger.info(f'Parsing {object_name}')
+
+            if object_name and self.metadata.get(object_name) is None:
+                self.metadata.get_metadata()
+                if self.metadata.get(object_name) is None:
+                    logger.warning(f'Metadata not found for {object_name}')
+
+            properties = (object_entry.get('content') or {}).get('m:properties') or {}
+
+            if object_type in REGISTER_TYPES:
+                self._get_register_records(object_name, properties)
+
+            if object_type in ENTITY_TYPES:
+                self._get_entity_records(object_name, properties)
+
+
+    def _add_records(self, object_name, new_records: list):
+        if new_records:
+            if object_name in self.keys():
+                self[object_name].add_records(new_records)
+            else:
+                metadata_obj = self.metadata.get(object_name)
+                self[object_name] = DataObject1C(metadata_obj=metadata_obj, records=new_records)
+
+    @staticmethod
+    def _convert_value(value: Any, type_name: str) -> Any:
+        # Конвертируем значение в нужный тип данных на основе метаданных.
+        if value is None:
+            return None
+        if not isinstance(value, str):
+            logger.warning(f'Expected value to be a string for conversion, got {type(value).__name__}: {value!r}')
+            return value
+        try:
+            if type_name == 'Boolean':
+                return value.lower() == 'true'
+            if type_name in ('Int64', 'Int16'):
+                return int(value)
+            if type_name == 'Double':
+                return float(value)
+            if type_name == 'DateTime':
+                return datetime.fromisoformat(value)
+            if type_name == 'Guid':
+                if value == '00000000-0000-0000-0000-000000000000':
+                    return None
+                else:
+                    return uuid.UUID(value)
+        except (ValueError, TypeError) as e:
+            logger.warning(f'Failed to convert value {value!r} to type {type_name}: {e}')
+        return value
+
+    def _get_record_fields(self, properties: dict, object_name: str | None = None) -> dict:
+        if object_name not in self.metadata.keys():
+            self.metadata.get_metadata()
+            if object_name not in self.metadata.keys():
+                logger.error(f'Metadata not found for {object_name}')
+                raise ValueError(f'Metadata not found for {object_name}')            
+        
+        metadata_obj = self.metadata[object_name]
+
+        fields = {}
+        for k, v in properties.items():
+            if k.startswith('d:') and isinstance(v, str):
+
+                field_name = k.removeprefix('d:')
+
+                if field_name.endswith('_Type'):
+                    # если поле заканчивается на _Type, то это поле составного типа
+                    # и в значении будет полное имя типа, например "StandardODATA.СправочникСсылка.Контрагенты"
+                    # для удобства убираем префикс и оставляем только имя типа, например "СправочникСсылка.Контрагенты"
+                    value = v.removeprefix(ODATA_PREFIX)
+                else:
+                    value = v
+
+                if field_name not in metadata_obj.keys():
+                    # поле не найдено в метаданных, пробуем их перечитать.
+                    self.metadata.get_metadata()
+                    metadata_obj = self.metadata[object_name]
+                    if field_name not in metadata_obj.keys():
+                        logger.warning(f'Metadata field {field_name} not found for object {object_name}')
+                        
+                type_name = metadata_obj.get(field_name) or 'String'
+
+                converted = self._convert_value(value, type_name)
+
+                fields[field_name] = converted
+
+        # Спец-поле: для документов/справочников True по пометке удаления,
+        # для регистров/табличных частей (нет DeletionMark) — False.
+        fields[IS_DELETED_OR_EMPTY_FIELD] = bool(fields.get(DELETION_MARK_FIELD))
+        fields[EXCHANGE_MESSAGE_NO_FIELD] = self.exchange_message_no
+
+        return fields
+
+    @staticmethod
+    def _default_key_value(type_name: str) -> Any:
+        # Дефолтное значение поля ключа для удаленной записи регистра:
+        # '' для строк, 0 для чисел, чтобы получить непустой составной ключ.
+        if type_name == 'String':
+            return ''
+        if type_name in ('Int64', 'Int16', 'Double'):
+            return 0
+        if type_name == 'Boolean':
+            return False
+        if type_name == 'DateTime':
+            return datetime(1, 1, 1)  # пустая дата 1С
+        return None  # Guid (Recorder перекрывается ниже) и прочее
+
+    def _make_deleted_register_record(self, object_name: str, recorder: str, recorder_type: str) -> dict:
+        """
+        Создает запись для удаленного набора записей регистра (пришел пустой RecordSet).
+        Заполняет полный первичный ключ из метаданных дефолтами по типу поля
+        и проставляет реальные Recorder и Recorder_Type.
+        """
+        primary_key = self.metadata[object_name].primary_key
+        record = {field: self._default_key_value(type_name)
+                  for field, type_name in primary_key.items()}
+
+        recorder_name, _ = parse_object_full_name(recorder_type)
+        record['Recorder'] = recorder
+        record['Recorder_Type'] = recorder_name
+        record[IS_DELETED_OR_EMPTY_FIELD] = True
+        record[EXCHANGE_MESSAGE_NO_FIELD] = self.exchange_message_no
+        return record
+
+    def _make_empty_table_part_record(self, table_part_name: str, ref_key: Any) -> dict:
+        """
+        Создает запись для опустевшей табличной части (пришла без строк), по аналогии с удаленным
+        набором регистра. Полный ключ из метаданных заполняется дефолтами, а Ref_Key —
+        реальным значением владельца, чтобы scoped-удаление по Ref_Key убрало старые строки.
+        """
+        primary_key = self.metadata[table_part_name].primary_key
+        record = {field: self._default_key_value(type_name)
+                  for field, type_name in primary_key.items()}
+        record['Ref_Key'] = ref_key
+        record[IS_DELETED_OR_EMPTY_FIELD] = True
+        record[EXCHANGE_MESSAGE_NO_FIELD] = self.exchange_message_no
+        return record
+
+    def _get_register_records(self, object_name: str, properties: dict):
+        """
+        Функция забирает записи регистра.
+
+        Регистраторный регистр приходит набором по одному регистратору (d:RecordSet с движениями);
+        пустой набор = набор удалён (фиктивная запись). Независимый регистр сведений приходит плоско —
+        поля прямо в properties, без Recorder/RecordSet, как у справочника/документа (форма прямого
+        чтения GET /InformationRegister_X — проверить на живой 1С).
+
+        Текущий объект это словарь, в котором ключом является объект 1С, например "Document_ЗаказКлиента",
+        значения содержат массив записей в виде list of dict.
+        """
+        recorder = properties.get('d:Recorder')
+        recorder_type = properties.get('d:Recorder_Type')
+
+        records = (properties.get('d:RecordSet') or {}).get('d:element') or []
+
+        if records:
+            new_records = [self._get_record_fields(record, object_name) for record in records]
+        elif recorder and recorder_type:
+            # Регистраторный регистр с пустым набором — набор записей удалён.
+            new_records = [self._make_deleted_register_record(object_name, recorder, recorder_type)]
+        elif recorder is None:
+            # Независимый регистр сведений: одна плоская запись, поля прямо в properties.
+            new_records = [self._get_record_fields(properties, object_name)]
+        else:
+            logger.error(f'No recorder or recorder type for {object_name}')
+            new_records = []
+
+        self._add_records(object_name, new_records)
+
+    def _get_record_table_parts(self, properties):
+        """
+        Ищем табличные части в свойствах объекта.
+        Если тип данных dict и если префикс в названии 'd:', то будем считать что это табличная часть
+        """
+        table_parts = {k.removeprefix('d:'): v for k, v in properties.items()
+                       if k.startswith('d:') and isinstance(v, dict) and v.get('@xsi:nil') != 'true'}
+        return table_parts
+
+    def _get_entity_records(self, object_name: str, properties: dict):
+        """
+        Функция забирает поля документа или справочника.
+        Запись одна, но могут быть табличные части, которые будут записаны в отдельные элементы структуры changes
+        """
+        fields = self._get_record_fields(properties, object_name)
+        self._add_records(object_name, [fields])
+
+        # Строки табличных частей приходят без ссылки на владельца — проставляем Ref_Key документа.
+        ref_key = fields.get('Ref_Key')
+        # Пометку удаления документа/справочника распространяем на его табличные части.
+        parent_deleted = fields.get(IS_DELETED_OR_EMPTY_FIELD)
+
+        table_parts = self._get_record_table_parts(properties)
+
+        for table_part_key, table_part in table_parts.items():
+            table_part_full_name = table_part.get('@m:type')
+            if table_part_full_name:
+                table_part_name, _ = parse_object_full_name(table_part_full_name)
+                table_part_rows = table_part.get('d:element') or []
+                if table_part_rows:
+                    for table_part_row in table_part_rows:
+                        row = self._get_record_fields(table_part_row, table_part_name)
+                        row['Ref_Key'] = ref_key
+                        row[IS_DELETED_OR_EMPTY_FIELD] = parent_deleted
+                        self._add_records(table_part_name, [row])
+                else:
+                    # Табличная часть пришла без строк — добавляем фиктивную запись,
+                    # чтобы scoped-удаление по Ref_Key убрало ранее сохраненные строки.
+                    ref_key = fields.get('Ref_Key')
+                    if ref_key is not None and table_part_name in self.metadata.keys():
+                        self._add_records(table_part_name,
+                                          [self._make_empty_table_part_record(table_part_name, ref_key)])
+
+                # Связываем объект-ТЧ с владельцем — чтобы to_nested_records нашёл его сам.
+                if table_part_name in self:
+                    self[object_name].table_parts[table_part_key] = self[table_part_name]