feather-cdc-postgres 0.1.0__py3-none-any.whl

pg_replication/README.md

@@ -0,0 +1,100 @@
+<!--
+VENDORED THIRD-PARTY CODE — read this before editing anything in this directory.
+
+Origin: the `pg_replication` verified source of https://github.com/dlt-hub/verified-sources
+Licence: Apache License 2.0, "Copyright 2023 The Contributors" — the full text is in
+         ./LICENSE, distributed with this package as section 4(a) requires.
+
+MODIFIED. Section 4(b) of the licence asks that changed files carry a prominent notice,
+so: `helpers.py` and `decoders.py` here are not upstream's. They carry the column
+deny-list projection, the reviewed-layout quarantine, mid-transaction rename handling,
+consistent baseline boundaries and generated-column publication that this runtime needs.
+
+It is vendored rather than depended on because upstream is a `dlt init` TEMPLATE, not a
+published distribution: there is no `pg_replication` on PyPI to pin. Upstream's own
+requirements are incomplete (dlt-hub/verified-sources#685), which is why this package
+declares `dlt[sql_database]` explicitly.
+
+The README below is upstream's, kept for the protocol and set-up notes it carries.
+-->
+
+# Postgres replication
+[Postgres](https://www.postgresql.org/) is one of the most popular relational database management systems. This verified source uses Postgres' replication functionality to efficiently process changes in tables (a process often referred to as _Change Data Capture_ or CDC). It uses [logical decoding](https://www.postgresql.org/docs/current/logicaldecoding.html) and the standard built-in `pgoutput` [output plugin](https://www.postgresql.org/docs/current/logicaldecoding-output-plugin.html).
+
+Resources that can be loaded using this verified source are:
+
+| Name                 | Description                                     |
+|----------------------|-------------------------------------------------|
+| replication_resource | Load published messages from a replication slot |
+| init_replication     | Initialize replication and optionally return snapshot resources for initial data load  |
+
+## Initialize the pipeline
+
+```bash
+dlt init pg_replication duckdb
+```
+
+This uses `duckdb` as destination, but you can choose any of the supported [destinations](https://dlthub.com/docs/dlt-ecosystem/destinations/).
+
+## Set up user
+
+The Postgres user needs to have the `LOGIN` and `REPLICATION` attributes assigned:
+
+```sql
+CREATE ROLE replication_user WITH LOGIN REPLICATION;
+```
+
+It also needs `CREATE` privilege on the database:
+
+```sql
+GRANT CREATE ON DATABASE dlt_data TO replication_user;
+```
+
+If not a superuser, the user must have ownership of the tables that need to be replicated:
+
+```sql
+ALTER TABLE your_table OWNER TO replication_user;
+```
+
+
+### Set up RDS
+1. You must enable replication for RDS Postgres instance via **Parameter Group**: https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/USER_PostgreSQL.Replication.ReadReplicas.html
+2. `WITH LOGIN REPLICATION;` does not work on RDS, instead do:
+```sql
+GRANT rds_replication TO replication_user;
+```
+3. Do not fallback to non SSL connection by setting connection parameters:
+```toml
+sources.pg_replication.credentials="postgresql://loader:password@host.rds.amazonaws.com:5432/dlt_data?sslmode=require&connect_timeout=300"
+```
+
+
+## Add credentials
+1. Open `.dlt/secrets.toml`.
+2. Enter your Postgres credentials:
+
+    ```toml
+    [sources.pg_replication]
+    credentials="postgresql://replication_user:<<password>>@localhost:5432/dlt_data"
+    ```
+3. Enter credentials for your chosen destination as per the [docs](https://dlthub.com/docs/dlt-ecosystem/destinations/).
+
+## Run the pipeline
+
+1. Install the necessary dependencies by running the following command:
+
+   ```bash
+   pip install -r requirements.txt
+   ```
+
+1. Now the pipeline can be run by using the command:
+
+   ```bash
+   python pg_replication_pipeline.py
+   ```
+
+1. To make sure that everything is loaded as expected, use the command:
+
+   ```bash
+   dlt pipeline pg_replication_pipeline show
+   ```

pg_replication/__init__.py

@@ -0,0 +1,106 @@
+"""Replicates postgres tables in batch using logical decoding."""
+
+from typing import Dict, Sequence, Optional, Iterable, Union
+
+import dlt
+
+from dlt.common import logger
+from dlt.common.typing import TDataItem
+from dlt.common.schema.typing import TTableSchemaColumns
+from dlt.extract.items import DataItemWithMeta
+from dlt.sources.credentials import ConnectionStringCredentials
+
+from .helpers import advance_slot, get_max_lsn, ItemGenerator
+
+
+@dlt.resource(
+    name=lambda args: args["slot_name"],
+    standalone=True,
+)
+def replication_resource(
+    slot_name: str,
+    pub_name: str,
+    credentials: ConnectionStringCredentials = dlt.secrets.value,
+    include_columns: Optional[Dict[str, Sequence[str]]] = None,
+    columns: Optional[Dict[str, TTableSchemaColumns]] = None,
+    target_batch_size: int = 1000,
+    flush_slot: bool = True,
+) -> Iterable[Union[TDataItem, DataItemWithMeta]]:
+    """Resource yielding data items for changes in one or more postgres tables.
+
+    - Relies on a replication slot and publication that publishes DML operations
+    (i.e. `insert`, `update`, and/or `delete`). Helper `init_replication` can be
+    used to set this up.
+    - Maintains LSN of last consumed message in state to track progress.
+    - At start of the run, advances the slot upto last consumed message in previous run.
+    - Processes in batches to limit memory usage.
+
+    Args:
+        slot_name (str): Name of the replication slot to consume replication messages from.
+        pub_name (str): Name of the publication that publishes DML operations for the table(s).
+        credentials (ConnectionStringCredentials): Postgres database credentials.
+        include_columns (Optional[Dict[str, Sequence[str]]]): Maps table name(s) to
+          sequence of names of columns to include in the generated data items.
+          Any column not in the sequence is excluded. If not provided, all columns
+          are included. For example:
+          ```
+          include_columns={
+              "table_x": ["col_a", "col_c"],
+              "table_y": ["col_x", "col_y", "col_z"],
+          }
+          ```
+        columns (Optional[Dict[str, TTableHintTemplate[TAnySchemaColumns]]]): Maps
+          table name(s) to column hints to apply on the replicated table(s). For example:
+          ```
+          columns={
+              "table_x": {"col_a": {"data_type": "json"}},
+              "table_y": {"col_y": {"precision": 32}},
+          }
+          ```
+        target_batch_size (int): Desired number of data items yielded in a batch.
+          Can be used to limit the data items in memory. Note that the number of
+          data items yielded can be (far) greater than `target_batch_size`, because
+          all messages belonging to the same transaction are always processed in
+          the same batch, regardless of the number of messages in the transaction
+          and regardless of the value of `target_batch_size`. The number of data
+          items can also be smaller than `target_batch_size` when the replication
+          slot is exhausted before a batch is full.
+        flush_slot (bool): Whether processed messages are discarded from the replication
+          slot. Recommended value is True. Be careful when setting False—not flushing
+          can eventually lead to a “disk full” condition on the server, because
+          the server retains all the WAL segments that might be needed to stream
+          the changes via all of the currently open replication slots.
+
+        Yields:
+            Data items for changes published in the publication.
+    """
+    # start where we left off in previous run
+    start_lsn = dlt.current.resource_state().get("last_commit_lsn", 0)
+    if flush_slot and start_lsn:
+        advance_slot(start_lsn, slot_name, credentials)
+
+    # continue until last message in replication slot
+    options = {"publication_names": pub_name, "proto_version": "1"}
+    upto_lsn = get_max_lsn(slot_name, options, credentials)
+    if upto_lsn is None:
+        return
+    logger.info(
+        f"Replicating slot {slot_name} publication {pub_name} from {start_lsn} to {upto_lsn}"
+    )
+    # generate items in batches
+    while True:
+        gen = ItemGenerator(
+            credentials=credentials,
+            slot_name=slot_name,
+            options=options,
+            upto_lsn=upto_lsn,
+            start_lsn=start_lsn,
+            target_batch_size=target_batch_size,
+            include_columns=include_columns,
+            columns=columns,
+        )
+        yield from gen
+        if gen.generated_all:
+            dlt.current.resource_state()["last_commit_lsn"] = gen.last_commit_lsn
+            break
+        start_lsn = gen.last_commit_lsn

pg_replication/decoders.py

@@ -0,0 +1,428 @@
+# flake8: noqa
+# file copied from https://raw.githubusercontent.com/dgea005/pypgoutput/master/src/pypgoutput/decoders.py
+# we do this instead of importing `pypgoutput` because it depends on `psycopg2`, which causes errors when installing on macOS
+
+import io
+from abc import ABC, abstractmethod
+from dataclasses import dataclass
+from datetime import datetime, timedelta, timezone
+from typing import List, NamedTuple, Optional, Union
+
+# integer byte lengths
+INT8 = 1
+INT16 = 2
+INT32 = 4
+INT64 = 8
+
+
+def convert_pg_ts(_ts_in_microseconds: int) -> datetime:
+    ts = datetime(2000, 1, 1, 0, 0, 0, 0, tzinfo=timezone.utc)
+    return ts + timedelta(microseconds=_ts_in_microseconds)
+
+
+def convert_bytes_to_int(_in_bytes: bytes) -> int:
+    return int.from_bytes(_in_bytes, byteorder="big", signed=True)
+
+
+def convert_bytes_to_utf8(_in_bytes: Union[bytes, bytearray]) -> str:
+    return (_in_bytes).decode("utf-8")
+
+
+class ColumnData(NamedTuple):
+    # col_data_category is NOT the type. it means null value/toasted(not sent)/text formatted
+    col_data_category: Optional[str]
+    col_data_length: Optional[int] = None
+    col_data: Optional[str] = None
+
+    def __repr__(self) -> str:
+        return f"[col_data_category='{self.col_data_category}', col_data_length={self.col_data_length}, col_data='{self.col_data}']"
+
+
+class ColumnType(NamedTuple):
+    """https://www.postgresql.org/docs/12/catalog-pg-attribute.html"""
+
+    part_of_pkey: int
+    name: str
+    type_id: int
+    atttypmod: int
+
+
+class TupleData(NamedTuple):
+    n_columns: int
+    column_data: List[ColumnData]
+
+    def __repr__(self) -> str:
+        return f"n_columns: {self.n_columns}, data: {self.column_data}"
+
+
+# TODO: you can make decoding way faster by
+# - moving all the decoding core to PgoutputMessage
+# - use struct unpack and increase offset manually to reduce calls
+# - use tuples to represent data, separate data from decoding!
+class PgoutputMessage(ABC):
+    def __init__(self, buffer: bytes):
+        self.buffer: io.BytesIO = io.BytesIO(buffer)
+        self.byte1: str = self.read_utf8(1)
+        self.decode_buffer()
+
+    @abstractmethod
+    def decode_buffer(self) -> None:
+        """Decoding is implemented for each message type"""
+
+    @abstractmethod
+    def __repr__(self) -> str:
+        """Implemented for each message type"""
+
+    def read_int8(self) -> int:
+        return convert_bytes_to_int(self.buffer.read(INT8))
+
+    def read_int16(self) -> int:
+        return convert_bytes_to_int(self.buffer.read(INT16))
+
+    def read_int32(self) -> int:
+        return convert_bytes_to_int(self.buffer.read(INT32))
+
+    def read_int64(self) -> int:
+        return convert_bytes_to_int(self.buffer.read(INT64))
+
+    def read_utf8(self, n: int = 1) -> str:
+        return convert_bytes_to_utf8(self.buffer.read(n))
+
+    def read_timestamp(self) -> datetime:
+        # 8 chars -> int64 -> timestamp
+        return convert_pg_ts(_ts_in_microseconds=self.read_int64())
+
+    def read_string(self) -> str:
+        output = bytearray()
+        while (next_char := self.buffer.read(1)) != b"\x00":
+            output += next_char
+        return convert_bytes_to_utf8(output)
+
+    def read_tuple_data(self) -> TupleData:
+        """
+        TupleData
+        Int16  Number of columns.
+        Next, one of the following submessages appears for each column (except generated columns):
+                Byte1('n') Identifies the data as NULL value.
+            Or
+                Byte1('u') Identifies unchanged TOASTed value (the actual value is not sent).
+            Or
+                Byte1('t') Identifies the data as text formatted value.
+                Int32 Length of the column value.
+                Byten The value of the column, in text format. (A future release might support additional formats.) n is the above length.
+        """
+        # TODO: investigate what happens with the generated columns
+        column_data = list()
+        n_columns = self.read_int16()
+        for column in range(n_columns):
+            col_data_category = self.read_utf8()
+            if col_data_category in ("n", "u"):
+                # "n"=NULL, "t"=TOASTed
+                column_data.append(ColumnData(col_data_category=col_data_category))
+            elif col_data_category == "t":
+                # t = tuple
+                col_data_length = self.read_int32()
+                col_data = self.read_utf8(col_data_length)
+                column_data.append(
+                    ColumnData(
+                        col_data_category=col_data_category,
+                        col_data_length=col_data_length,
+                        col_data=col_data,
+                    )
+                )
+        return TupleData(n_columns=n_columns, column_data=column_data)
+
+
+class Begin(PgoutputMessage):
+    """
+    https://pgpedia.info/x/xlogrecptr.html
+    https://www.postgresql.org/docs/14/datatype-pg-lsn.html
+
+    byte1 Byte1('B') Identifies the message as a begin message.
+    lsn Int64 The final LSN of the transaction.
+    commit_tx_ts Int64 Commit timestamp of the transaction. The value is in number of microseconds since PostgreSQL epoch (2000-01-01).
+    tx_xid Int32 Xid of the transaction.
+    """
+
+    byte1: str
+    lsn: int
+    commit_ts: datetime
+    tx_xid: int
+
+    def decode_buffer(self) -> None:
+        if self.byte1 != "B":
+            raise ValueError("first byte in buffer does not match Begin message")
+        self.lsn = self.read_int64()
+        self.commit_ts = self.read_timestamp()
+        self.tx_xid = self.read_int64()
+
+    def __repr__(self) -> str:
+        return (
+            f"BEGIN \n\tbyte1: '{self.byte1}', \n\tLSN: {self.lsn}, "
+            f"\n\tcommit_ts {self.commit_ts}, \n\ttx_xid: {self.tx_xid}"
+        )
+
+
+class Commit(PgoutputMessage):
+    """
+    byte1: Byte1('C') Identifies the message as a commit message.
+    flags: Int8 Flags; currently unused (must be 0).
+    lsn_commit: Int64 The LSN of the commit.
+    lsn: Int64 The end LSN of the transaction.
+    Int64 Commit timestamp of the transaction. The value is in number of microseconds since PostgreSQL epoch (2000-01-01).
+    """
+
+    byte1: str
+    flags: int
+    lsn_commit: int
+    lsn: int
+    commit_ts: datetime
+
+    def decode_buffer(self) -> None:
+        if self.byte1 != "C":
+            raise ValueError("first byte in buffer does not match Commit message")
+        self.flags = self.read_int8()
+        self.lsn_commit = self.read_int64()
+        self.lsn = self.read_int64()
+        self.commit_ts = self.read_timestamp()
+
+    def __repr__(self) -> str:
+        return (
+            f"COMMIT \n\tbyte1: {self.byte1}, \n\tflags {self.flags}, \n\tlsn_commit: {self.lsn_commit}"
+            f"\n\tLSN: {self.lsn}, \n\tcommit_ts {self.commit_ts}"
+        )
+
+
+class Origin:
+    """
+    Byte1('O') Identifies the message as an origin message.
+    Int64  The LSN of the commit on the origin server.
+    String Name of the origin.
+    Note that there can be multiple Origin messages inside a single transaction.
+    This seems to be what origin means: https://www.postgresql.org/docs/12/replication-origins.html
+    """
+
+    pass
+
+
+class Relation(PgoutputMessage):
+    """
+    Byte1('R')  Identifies the message as a relation message.
+    Int32 ID of the relation.
+    String Namespace (empty string for pg_catalog).
+    String Relation name.
+    Int8 Replica identity setting for the relation (same as relreplident in pg_class).
+        # select relreplident from pg_class where relname = 'test_table';
+        # from reading the documentation and looking at the tables this is not int8 but a single character
+        # background: https://www.postgresql.org/docs/10/sql-altertable.html#SQL-CREATETABLE-REPLICA-IDENTITY
+    Int16 Number of columns.
+    Next, the following message part appears for each column (except generated columns):
+        Int8 Flags for the column. Currently can be either 0 for no flags or 1 which marks the column as part of the key.
+        String Name of the column.
+        Int32 ID of the column's data type.
+        Int32 Type modifier of the column (atttypmod).
+    """
+
+    byte1: str
+    relation_id: int
+    namespace: str
+    relation_name: str
+    replica_identity_setting: str
+    n_columns: int
+    columns: List[ColumnType]
+
+    def decode_buffer(self) -> None:
+        if self.byte1 != "R":
+            raise ValueError("first byte in buffer does not match Relation message")
+        self.relation_id = self.read_int32()
+        self.namespace = self.read_string()
+        self.relation_name = self.read_string()
+        self.replica_identity_setting = self.read_utf8()
+        self.n_columns = self.read_int16()
+        self.columns = list()
+
+        for column in range(self.n_columns):
+            part_of_pkey = self.read_int8()
+            col_name = self.read_string()
+            data_type_id = self.read_int32()
+            # TODO: check on use of signed / unsigned
+            # check with select oid from pg_type where typname = <type>; timestamp == 1184, int4 = 23
+            col_modifier = self.read_int32()
+            self.columns.append(
+                ColumnType(
+                    part_of_pkey=part_of_pkey,
+                    name=col_name,
+                    type_id=data_type_id,
+                    atttypmod=col_modifier,
+                )
+            )
+
+    def __repr__(self) -> str:
+        return (
+            f"RELATION \n\tbyte1: '{self.byte1}', \n\trelation_id: {self.relation_id}"
+            f",\n\tnamespace/schema: '{self.namespace}',\n\trelation_name: '{self.relation_name}'"
+            f",\n\treplica_identity_setting: '{self.replica_identity_setting}',\n\tn_columns: {self.n_columns} "
+            f",\n\tcolumns: {self.columns}"
+        )
+
+
+class PgType:
+    """
+    Renamed to PgType not to collide with "type"
+
+    Byte1('Y') Identifies the message as a type message.
+    Int32 ID of the data type.
+    String Namespace (empty string for pg_catalog).
+    String Name of the data type.
+    """
+
+    pass
+
+
+class Insert(PgoutputMessage):
+    """
+    Byte1('I')  Identifies the message as an insert message.
+    Int32 ID of the relation corresponding to the ID in the relation message.
+    Byte1('N') Identifies the following TupleData message as a new tuple.
+    TupleData TupleData message part representing the contents of new tuple.
+    """
+
+    byte1: str
+    relation_id: int
+    new_tuple_byte: str
+    new_tuple: TupleData
+
+    def decode_buffer(self) -> None:
+        if self.byte1 != "I":
+            raise ValueError(
+                f"first byte in buffer does not match Insert message (expected 'I', got '{self.byte1}'"
+            )
+        self.relation_id = self.read_int32()
+        self.new_tuple_byte = self.read_utf8()
+        self.new_tuple = self.read_tuple_data()
+
+    def __repr__(self) -> str:
+        return (
+            f"INSERT \n\tbyte1: '{self.byte1}', \n\trelation_id: {self.relation_id} "
+            f"\n\tnew tuple byte: '{self.new_tuple_byte}', \n\tnew_tuple: {self.new_tuple}"
+        )
+
+
+class Update(PgoutputMessage):
+    """
+    Byte1('U')      Identifies the message as an update message.
+    Int32           ID of the relation corresponding to the ID in the relation message.
+    Byte1('K')      Identifies the following TupleData submessage as a key. This field is optional and is only present if the update changed data in any of the column(s) that are part of the REPLICA IDENTITY index.
+    Byte1('O')      Identifies the following TupleData submessage as an old tuple. This field is optional and is only present if table in which the update happened has REPLICA IDENTITY set to FULL.
+    TupleData       TupleData message part representing the contents of the old tuple or primary key. Only present if the previous 'O' or 'K' part is present.
+    Byte1('N')      Identifies the following TupleData message as a new tuple.
+    TupleData       TupleData message part representing the contents of a new tuple.
+
+    The Update message may contain either a 'K' message part or an 'O' message part or neither of them, but never both of them.
+    """
+
+    byte1: str
+    relation_id: int
+    next_byte_identifier: Optional[str]
+    optional_tuple_identifier: Optional[str]
+    old_tuple: Optional[TupleData]
+    new_tuple_byte: str
+    new_tuple: TupleData
+
+    def decode_buffer(self) -> None:
+        self.optional_tuple_identifier = None
+        self.old_tuple = None
+        if self.byte1 != "U":
+            raise ValueError(
+                f"first byte in buffer does not match Update message (expected 'U', got '{self.byte1}'"
+            )
+        self.relation_id = self.read_int32()
+        # TODO test update to PK, test update with REPLICA IDENTITY = FULL
+        self.next_byte_identifier = self.read_utf8()  # one of K, O or N
+        if self.next_byte_identifier == "K" or self.next_byte_identifier == "O":
+            self.optional_tuple_identifier = self.next_byte_identifier
+            self.old_tuple = self.read_tuple_data()
+            self.new_tuple_byte = self.read_utf8()
+        else:
+            self.new_tuple_byte = self.next_byte_identifier
+        if self.new_tuple_byte != "N":
+            # TODO: test exception handling
+            raise ValueError(
+                f"did not find new_tuple_byte ('N') at position: {self.buffer.tell()}, found: '{self.new_tuple_byte}'"
+            )
+        self.new_tuple = self.read_tuple_data()
+
+    def __repr__(self) -> str:
+        return (
+            f"UPDATE \n\tbyte1: '{self.byte1}', \n\trelation_id: {self.relation_id}"
+            f"\n\toptional_tuple_identifier: '{self.optional_tuple_identifier}', \n\toptional_old_tuple_data: {self.old_tuple}"
+            f"\n\tnew_tuple_byte: '{self.new_tuple_byte}', \n\tnew_tuple: {self.new_tuple}"
+        )
+
+
+class Delete(PgoutputMessage):
+    """
+    Byte1('D')      Identifies the message as a delete message.
+    Int32           ID of the relation corresponding to the ID in the relation message.
+    Byte1('K')      Identifies the following TupleData submessage as a key. This field is present if the table in which the delete has happened uses an index as REPLICA IDENTITY.
+    Byte1('O')      Identifies the following TupleData message as a old tuple. This field is present if the table in which the delete has happened has REPLICA IDENTITY set to FULL.
+    TupleData       TupleData message part representing the contents of the old tuple or primary key, depending on the previous field.
+
+    The Delete message may contain either a 'K' message part or an 'O' message part, but never both of them.
+    """
+
+    byte1: str
+    relation_id: int
+    message_type: str
+    old_tuple: TupleData
+
+    def decode_buffer(self) -> None:
+        if self.byte1 != "D":
+            raise ValueError(
+                f"first byte in buffer does not match Delete message (expected 'D', got '{self.byte1}'"
+            )
+        self.relation_id = self.read_int32()
+        self.message_type = self.read_utf8()
+        # TODO: test with replica identity full
+        if self.message_type not in ["K", "O"]:
+            raise ValueError(
+                f"message type byte is not 'K' or 'O', got: '{self.message_type}'"
+            )
+        self.old_tuple = self.read_tuple_data()
+
+    def __repr__(self) -> str:
+        return (
+            f"DELETE \n\tbyte1: {self.byte1} \n\trelation_id: {self.relation_id} "
+            f"\n\tmessage_type: {self.message_type} \n\told_tuple: {self.old_tuple}"
+        )
+
+
+class Truncate(PgoutputMessage):
+    """
+    Byte1('T')      Identifies the message as a truncate message.
+    Int32           Number of relations
+    Int8            Option bits for TRUNCATE: 1 for CASCADE, 2 for RESTART IDENTITY
+    Int32           ID of the relation corresponding to the ID in the relation message. This field is repeated for each relation.
+    """
+
+    byte1: str
+    number_of_relations: int
+    option_bits: int
+    relation_ids: List[int]
+
+    def decode_buffer(self) -> None:
+        if self.byte1 != "T":
+            raise ValueError(
+                f"first byte in buffer does not match Truncate message (expected 'T', got '{self.byte1}'"
+            )
+        self.number_of_relations = self.read_int32()
+        self.option_bits = self.read_int8()
+        self.relation_ids = []
+        for relation in range(self.number_of_relations):
+            self.relation_ids.append(self.read_int32())
+
+    def __repr__(self) -> str:
+        return (
+            f"TRUNCATE \n\tbyte1: {self.byte1} \n\tn_relations: {self.number_of_relations} "
+            f"option_bits: {self.option_bits}, relation_ids: {self.relation_ids}"
+        )

pg_replication/exceptions.py

@@ -0,0 +1,6 @@
+class NoPrimaryKeyException(Exception):
+    pass
+
+
+class IncompatiblePostgresVersionException(Exception):
+    pass