pgpack-dumper 0.1.2__tar.gz

pgpack_dumper-0.1.2/CHANGELOG.md

@@ -0,0 +1,32 @@
+# Version History
+
+## 0.1.2
+
+* Change metadata structure
+* Update requirements.txt
+
+## 0.1.1
+
+* Rename project to pgpack_dumper
+* Fix legacy setup.py bdist_wheel mechanism, which will be removed in a future version
+* Fix multiquery
+* Add CHANGELOG.md
+
+## 0.1.0
+
+* Add CopyBufferObjectError & CopyBufferTableNotDefined
+* Add PGObject
+* Add logger
+* Add sqlparse for cut comments from query
+* Add multiquery
+* Update requirements.txt
+
+## 0.0.2
+
+* Fix include *.sql
+* Fix requirements.txt
+* Docs change README.md
+
+## 0.0.1
+
+First version of the library pgcrypt_dumper

pgpack_dumper-0.1.2/MANIFEST.in

@@ -0,0 +1 @@
+recursive-include pgpack_dumper *.sql

pgpack_dumper-0.1.2/PKG-INFO

@@ -0,0 +1,139 @@
+Metadata-Version: 2.1
+Name: pgpack_dumper
+Version: 0.1.2
+Summary: Library for read and write PGPack format between PostgreSQL and file.
+Home-page: https://github.com/0xMihalich/pgpack_dumper
+Author: 0xMihalich
+Author-email: bayanmobile87@gmail.com
+Description-Content-Type: text/markdown
+License-File: README.md
+License-File: CHANGELOG.md
+Requires-Dist: pgpack==0.1.3
+Requires-Dist: psycopg>=3.2.9
+Requires-Dist: sqlparse>=0.5.3
+
+# PGPackDumper
+
+Library for read and write PGPack format between PostgreSQL and file
+
+## Examples
+
+### Initialization
+
+```python
+from pgpack_dumper import (
+    CompressionMethod,
+    PGConnector,
+    PGPackDumper,
+)
+
+connector = PGConnector(
+    host = <your host>,
+    dbname = <your database>,
+    user = <your username>,
+    password = <your password>,
+    port = <your port>,
+)
+
+dumper = PGPackDumper(
+    connector=connector,
+    compression_method=CompressionMethod.LZ4,  # or CompressionMethod.ZSTD or CompressionMethod.NONE
+)
+```
+
+### Read dump from PostgreSQL into file
+
+```python
+file_name = "pgpack.lz4"
+# you need define one of parameter query or table_name
+query = "select ..."  # some sql query
+table_name = "public.test_table"  # or some table
+
+with open(file_name, "wb") as fileobj:
+    dumper.read_dump(
+        fileobj,
+        query,
+        table_name,
+    )
+```
+
+### Write dump from file into PostgreSQL
+
+```python
+file_name = "pgpack.lz4"
+# you need define one of parameter table_name
+table_name = "public.test_table"  # some table
+
+with open(file_name, "rb") as fileobj:
+    dumper.write_dump(
+        fileobj,
+        table_name,
+    )
+```
+
+### Write from PostgreSQL into PostgreSQL
+
+Same server
+
+```python
+
+table_dest = "public.test_table_write"  # some table for write
+table_src = "public.test_table_read"  # some table for read
+query_src = "select ..."  # or some sql query for read
+
+dumper.write_between(
+    table_dest,
+    table_src,
+    query_src,
+)
+```
+
+Different servers
+
+```python
+
+connector_src = PGConnector(
+    host = <host src>,
+    dbname = <database src>,
+    user = <username src>,
+    password = <password src>,
+    port = <port src>,
+)
+
+dumper_src = PGPackDumper(connector=connector_src)
+
+table_dest = "public.test_table_write"  # some table for write
+table_src = "public.test_table_read"  # some table for read
+query_src = "select ..."  # or some sql query for read
+
+dumper.write_between(
+    table_dest,
+    table_src,
+    query_src,
+    dumper_src.cursor,
+)
+```
+
+### Open PGPack file format
+
+Get info from my another repository https://github.com/0xMihalich/pgpack
+
+## Installation
+
+### From pip
+
+```bash
+pip install pgpack_dumper
+```
+
+### From local directory
+
+```bash
+pip install .
+```
+
+### From git
+
+```bash
+pip install git+https://github.com/0xMihalich/pgpack_dumper
+```

pgpack_dumper-0.1.2/README.md

@@ -0,0 +1,125 @@
+# PGPackDumper
+
+Library for read and write PGPack format between PostgreSQL and file
+
+## Examples
+
+### Initialization
+
+```python
+from pgpack_dumper import (
+    CompressionMethod,
+    PGConnector,
+    PGPackDumper,
+)
+
+connector = PGConnector(
+    host = <your host>,
+    dbname = <your database>,
+    user = <your username>,
+    password = <your password>,
+    port = <your port>,
+)
+
+dumper = PGPackDumper(
+    connector=connector,
+    compression_method=CompressionMethod.LZ4,  # or CompressionMethod.ZSTD or CompressionMethod.NONE
+)
+```
+
+### Read dump from PostgreSQL into file
+
+```python
+file_name = "pgpack.lz4"
+# you need define one of parameter query or table_name
+query = "select ..."  # some sql query
+table_name = "public.test_table"  # or some table
+
+with open(file_name, "wb") as fileobj:
+    dumper.read_dump(
+        fileobj,
+        query,
+        table_name,
+    )
+```
+
+### Write dump from file into PostgreSQL
+
+```python
+file_name = "pgpack.lz4"
+# you need define one of parameter table_name
+table_name = "public.test_table"  # some table
+
+with open(file_name, "rb") as fileobj:
+    dumper.write_dump(
+        fileobj,
+        table_name,
+    )
+```
+
+### Write from PostgreSQL into PostgreSQL
+
+Same server
+
+```python
+
+table_dest = "public.test_table_write"  # some table for write
+table_src = "public.test_table_read"  # some table for read
+query_src = "select ..."  # or some sql query for read
+
+dumper.write_between(
+    table_dest,
+    table_src,
+    query_src,
+)
+```
+
+Different servers
+
+```python
+
+connector_src = PGConnector(
+    host = <host src>,
+    dbname = <database src>,
+    user = <username src>,
+    password = <password src>,
+    port = <port src>,
+)
+
+dumper_src = PGPackDumper(connector=connector_src)
+
+table_dest = "public.test_table_write"  # some table for write
+table_src = "public.test_table_read"  # some table for read
+query_src = "select ..."  # or some sql query for read
+
+dumper.write_between(
+    table_dest,
+    table_src,
+    query_src,
+    dumper_src.cursor,
+)
+```
+
+### Open PGPack file format
+
+Get info from my another repository https://github.com/0xMihalich/pgpack
+
+## Installation
+
+### From pip
+
+```bash
+pip install pgpack_dumper
+```
+
+### From local directory
+
+```bash
+pip install .
+```
+
+### From git
+
+```bash
+pip install git+https://github.com/0xMihalich/pgpack_dumper
+```

pgpack_dumper-0.1.2/pgpack_dumper/__init__.py

@@ -0,0 +1,35 @@
+"""Library for read and write PGPack format between PostgreSQL and file."""
+
+from pgcopylib import PGCopy
+from pgpack import (
+    CompressionMethod,
+    PGPackReader,
+    PGPackWriter,
+)
+
+from .connector import PGConnector
+from .copy import CopyBuffer
+from .dumper import PGPackDumper
+from .errors import (
+    CopyBufferError,
+    CopyBufferObjectError,
+    CopyBufferTableNotDefined,
+    PGPackDumperError,
+)
+from .version import __version__
+
+__all__ = (
+    "__version__",
+    "CompressionMethod",
+    "CopyBuffer",
+    "CopyBufferError",
+    "CopyBufferObjectError",
+    "CopyBufferTableNotDefined",
+    "PGConnector",
+    "PGCopy",
+    "PGPackDumper",
+    "PGPackDumperError",
+    "PGPackReader",
+    "PGPackWriter",
+)
+__author__ = "0xMihalich"

pgpack_dumper-0.1.2/pgpack_dumper/connector.py

@@ -0,0 +1,11 @@
+from typing import NamedTuple
+
+
+class PGConnector(NamedTuple):
+    """Connector for PostgreSQL."""
+
+    host: str
+    dbname: str
+    user: str
+    password: str
+    port: int

pgpack_dumper-0.1.2/pgpack_dumper/copy.py

@@ -0,0 +1,166 @@
+from io import BufferedReader
+from logging import Logger
+from typing import (
+    Generator,
+    Iterator,
+)
+
+from psycopg import (
+    Copy,
+    Cursor,
+)
+
+from .errors import (
+    CopyBufferObjectError,
+    CopyBufferTableNotDefined,
+)
+from .query_template import query_template
+from .search_object import search_object
+from .structs import PGObject
+from .metadata import read_metadata
+
+
+class CopyBuffer:
+
+    def __init__(
+        self,
+        cursor: Cursor,
+        logger: Logger,
+        query: str | None = None,
+        table_name: str | None = None,
+    ) -> None:
+        """Class initialization."""
+
+        self.cursor = cursor
+        self.logger = logger
+        self.query = query
+        self.table_name = table_name
+        self.pos = 0
+
+    @property
+    def metadata(self) -> bytes:
+        """Get metadata as bytes."""
+
+        host = self.cursor.connection.info.host
+        self.logger.info(f"Start read metadata from host {host}.")
+        metadata = read_metadata(
+            self.cursor,
+            self.query,
+            self.table_name,
+        )
+        self.logger.info(f"Read metadata from host {host} done.")
+        return metadata
+
+    def copy_to(self) -> Iterator[Copy]:
+        """Get copy object from PostgreSQL."""
+
+        if not self.query and not self.table_name:
+            error_msg = "Query or table not defined."
+            self.logger.error(error_msg)
+            raise CopyBufferTableNotDefined(error_msg)
+
+        host = self.cursor.connection.info.host
+
+        if not self.query:
+            self.logger.info(f"Start read from {host}.{self.table_name}.")
+            self.cursor.execute(query_template("relkind").format(
+                table_name=self.table_name,
+            ))
+            relkind = self.cursor.fetchone()[0]
+            pg_object = PGObject[relkind]
+            if not pg_object.is_readable:
+                error_msg = f"Read from {pg_object} not support."
+                self.logger.error(error_msg)
+                raise CopyBufferObjectError(error_msg)
+            self.logger.info(f"Use method read from {pg_object}.")
+            if not pg_object.is_readobject:
+                self.table_name = f"(select * from {self.table_name})"
+        elif self.query:
+            self.logger.info(f"Start read query from {host}.")
+            self.logger.info("Use method read from select.")
+            self.table_name = f"({self.query})"
+
+        return self.cursor.copy(
+            query_template("copy_to").format(table_name=self.table_name)
+        )
+
+    def copy_from(
+        self,
+        copyobj: BufferedReader,
+    ) -> None:
+        """Write PGCopy dump into PostgreSQL."""
+
+        if not self.table_name:
+            error_msg = "Table not defined."
+            self.logger.error(error_msg)
+            raise CopyBufferTableNotDefined(error_msg)
+
+        host = self.cursor.connection.info.host
+        self.logger.info(f"Start write into {host}.{self.table_name}.")
+
+        with self.cursor.copy(
+            query_template("copy_from").format(table_name=self.table_name)
+        ) as cp:
+            while chunk := copyobj.read(262_144):
+                cp.write(chunk)
+
+        self.logger.info(f"Write into {host}.{self.table_name} done.")
+
+    def copy_between(
+        self,
+        copy_buffer: "CopyBuffer",
+    ) -> None:
+        """Write from PostgreSQL into PostgreSQL."""
+
+        with copy_buffer.copy_to() as copy_to:
+            destination_host = self.cursor.connection.info.host
+            source_host = copy_buffer.cursor.connection.info.host
+            source_object = search_object(
+                copy_buffer.table_name,
+                copy_buffer.query,
+            )
+            self.logger.info(
+                f"Copy {source_object} from {source_host} into "
+                f"{destination_host}.{self.table_name} started."
+            )
+            with self.cursor.copy(
+                query_template("copy_from").format(table_name=self.table_name)
+            ) as copy_from:
+                [copy_from.write(data) for data in copy_to]
+            self.logger.info(
+                f"Copy {source_object} from {source_host}"
+                f"into {destination_host}.{self.table_name} done."
+            )
+
+    def copy_reader(self, size: int = -1) -> Generator[bytes, None, None]:
+        """Read bytes from copy object."""
+
+        host = self.cursor.connection.info.host
+        source = search_object(
+            self.table_name,
+            self.query,
+        )
+
+        with self.copy_to() as copy_object:
+            for data in copy_object:
+                self.pos += len(data)
+                if size != -1 and self.pos >= size:
+                    try:
+                        end_pos = size % (self.pos - len(data))
+                    except ZeroDivisionError:
+                        end_pos = size
+                    yield data[:end_pos]
+                    break
+                yield data
+
+        self.logger.info(f"Read {source} from {host} done.")
+
+    def read(self, size: int = -1) -> bytes:
+        """Read bytes from copy object."""
+
+        return b"".join(self.copy_reader(size))
+
+    def tell(self) -> int:
+        """Get read size."""
+
+        return self.pos

pgpack_dumper-0.1.2/pgpack_dumper/dumper.py

@@ -0,0 +1,169 @@
+from io import (
+    BufferedReader,
+    BufferedWriter,
+)
+from logging import Logger
+from types import MethodType
+
+from pgpack import (
+    CompressionMethod,
+    PGPackReader,
+    PGPackWriter,
+)
+from psycopg import (
+    Connection,
+    Cursor,
+)
+from sqlparse import format as sql_format
+
+from .copy import CopyBuffer
+from .connector import PGConnector
+from .errors import PGPackDumperError
+from .logger import DumperLogger
+from .multiquery import chunk_query
+
+
+class PGPackDumper:
+    """Class for read and write PGPack format."""
+
+    def __init__(
+        self,
+        connector: PGConnector,
+        compression_method: CompressionMethod = CompressionMethod.LZ4,
+        logger: Logger = DumperLogger(),
+    ) -> None:
+        """Class initialization."""
+
+        try:
+            self.connector: PGConnector = connector
+            self.connect: Connection = Connection.connect(
+                **self.connector._asdict()
+            )
+            self.cursor: Cursor = self.connect.cursor()
+            self.compression_method: CompressionMethod = compression_method
+            self.logger = logger
+            self.copy_buffer: CopyBuffer = CopyBuffer(self.cursor, self.logger)
+        except Exception as error:
+            logger.error(error)
+            raise PGPackDumperError(error)
+
+        self.logger.info(
+            f"PGPackDumper initialized for host {self.connector.host}."
+        )
+
+    @staticmethod
+    def multiquery(dump_method: MethodType):
+        """Multiquery decorator."""
+
+        def wrapper(*args, **kwargs):
+
+            first_part: list[str]
+            second_part: list[str]
+
+            self: PGPackDumper = args[0]
+            cursor: Cursor = kwargs.get("cursor_src") or self.cursor
+            query: str = kwargs.get("query_src") or kwargs.get("query")
+            part: int = 0
+            first_part, second_part = chunk_query(self.query_formatter(query))
+
+            if first_part:
+                self.logger.info("Multiquery detected.")
+
+                for query in first_part:
+                    self.logger.info(f"Execute query {part}.")
+                    cursor.execute(query)
+                    part += 1
+
+            if second_part:
+                for key in ("query", "query_src"):
+                    if key in kwargs:
+                        kwargs[key] = second_part.pop(0)
+                        break
+
+            self.logger.info(f"Execute query {part or ''}(copy method).")
+            dump_method(*args, **kwargs)
+
+            if second_part:
+                for query in second_part:
+                    part += 1
+                    self.logger.info(f"Execute query {part}.")
+                    cursor.execute(query)
+
+        return wrapper
+
+    def query_formatter(self, query: str) -> str | None:
+        """Reformat query."""
+
+        if not query:
+            return
+        return sql_format(sql=query, strip_comments=True).strip().strip(";")
+
+    def make_buffer_obj(
+        self,
+        cursor: Cursor | None = None,
+        query: str | None = None,
+        table_name: str | None = None,
+    ) -> CopyBuffer:
+        """Make new buffer object for read."""
+
+        cursor = cursor or Connection.connect(
+            **self.connector._asdict()
+        ).cursor()
+        host = cursor.connection.info.host
+        self.logger.info(f"Make new cursor object for host {host}.")
+
+        return CopyBuffer(
+            cursor,
+            query,
+            table_name,
+        )
+
+    @multiquery
+    def read_dump(
+        self,
+        fileobj: BufferedWriter,
+        query: str | None = None,
+        table_name: str | None = None,
+    ) -> None:
+        """Read PGPack dump from PostgreSQL/GreenPlum."""
+
+        pgpack = PGPackWriter(fileobj, self.compression_method)
+        self.copy_buffer.query = query
+        self.copy_buffer.table_name = table_name
+        pgpack.write(
+            self.copy_buffer.metadata,
+            self.copy_buffer,
+        )
+
+    def write_dump(
+        self,
+        fileobj: BufferedReader,
+        table_name: str,
+    ) -> None:
+        """Write PGPack dump into PostgreSQL/GreenPlum."""
+
+        fileobj.seek(0)
+        pgpack = PGPackReader(fileobj)
+        pgpack.pgcopy_compressor.seek(0)
+        self.copy_buffer.table_name = table_name
+        self.copy_buffer.copy_from(pgpack.pgcopy_compressor)
+        self.connect.commit()
+
+    @multiquery
+    def write_between(
+        self,
+        table_dest: str,
+        table_src: str | None = None,
+        query_src: str | None = None,
+        cursor_src: Cursor | None = None,
+    ) -> None:
+        """Write from PostgreSQL/GreenPlum into PostgreSQL/GreenPlum."""
+
+        source_copy_buffer = self.make_buffer_obj(
+            cursor=cursor_src,
+            query=query_src,
+            table_name=table_src,
+        )
+        self.copy_buffer.table_name = table_dest
+        self.copy_buffer.copy_between(source_copy_buffer)
+        self.connect.commit()

pgpack_dumper-0.1.2/pgpack_dumper/errors.py

@@ -0,0 +1,14 @@
+class CopyBufferError(Exception):
+    """CopyBuffer base error."""
+
+
+class CopyBufferObjectError(TypeError):
+    """Destination object not support."""
+
+
+class CopyBufferTableNotDefined(ValueError):
+    """Destination table not defined."""
+
+
+class PGPackDumperError(Exception):
+    """PGPackDumper base error."""

pgpack_dumper-0.1.2/pgpack_dumper/logger.py

@@ -0,0 +1,67 @@
+from datetime import datetime
+from logging import (
+    DEBUG,
+    FileHandler,
+    Formatter,
+    Logger,
+    StreamHandler,
+)
+from os import makedirs
+from os.path import dirname
+from sys import stdout
+
+from .version import __version__
+
+
+def root_dir() -> str:
+    """Get project directory."""
+
+    import __main__
+
+    return dirname(__main__.__file__)
+
+
+class DumperLogger(Logger):
+    """PGPackDumper logger."""
+
+    def __init__(
+            self,
+            level: int = DEBUG,
+            use_console: bool = True,
+    ) -> None:
+        """Class initialize."""
+
+        super().__init__("PGPackDumper")
+
+        self.fmt = (
+            f"%(asctime)s | %(levelname)-8s | ver {__version__}"
+            "| %(funcName)s-%(filename)s-%(lineno)04d <%(message)s>"
+        )
+        self.setLevel(level)
+        self.log_path = f"{root_dir()}/pgpack_logs"
+        makedirs(self.log_path, exist_ok=True)
+
+        formatter = Formatter(
+            fmt=self.fmt,
+            datefmt="%Y-%m-%d %H:%M:%S",
+        )
+
+        file_handler = FileHandler(
+            "{}/{:%Y-%m-%d}_{}.log".format(
+                self.log_path,
+                datetime.now(),
+                self.name,
+            ),
+            encoding="utf-8",
+        )
+        file_handler.setLevel(DEBUG)
+        file_handler.setFormatter(formatter)
+        self.addHandler(file_handler)
+
+        if use_console:
+            console_handler = StreamHandler(stdout)
+            console_handler.setLevel(level)
+            console_handler.setFormatter(formatter)
+            self.addHandler(console_handler)
+
+        self.propagate = False

pgpack_dumper-0.1.2/pgpack_dumper/metadata.py

@@ -0,0 +1,36 @@
+from psycopg import Cursor
+
+from .query_template import query_template
+from .random_name import random_name
+
+
+def read_metadata(
+    cursor: Cursor,
+    query: str | None = None,
+    table_name: str | None = None,
+) -> bytes:
+    """Read metadata for query or table."""
+
+    if not query and not table_name:
+        raise ValueError()
+
+    if query:
+        session_name = random_name()
+        prepare_name = f"{session_name}_prepare"
+        table_name = f"{session_name}_temp"
+        cursor.execute(query_template("prepare").format(
+            prepare_name=prepare_name,
+            query=query,
+            table_name=table_name,
+        ))
+
+    cursor.execute(query_template("attributes").format(
+        table_name=table_name,
+    ))
+
+    metadata: bytes = cursor.fetchone()[0]
+
+    if query:
+        cursor.execute(f"drop table if exists {table_name};")
+
+    return metadata

pgpack_dumper-0.1.2/pgpack_dumper/multiquery.py

@@ -0,0 +1,22 @@
+def chunk_query(query: str | None) -> tuple[list[str]]:
+    """Chunk multiquery to queryes."""
+
+    if not query:
+        return [], []
+
+    first_part: list[str] = [
+        part.strip()
+        for part in query.split(";")
+    ]
+    second_part: list[str] = []
+
+    for _ in first_part:
+        second_part.append(first_part.pop())
+        if any(
+            word == second_part[-1][:len(word)].lower()
+            for word in ("with", "select")
+        ):
+            second_part = list(reversed(second_part))
+            break
+
+    return first_part, second_part

pgpack_dumper-0.1.2/pgpack_dumper/query_path.py

@@ -0,0 +1,7 @@
+from pathlib import Path
+
+
+def query_path() -> str:
+    """Path for queryes."""
+
+    return f"{Path(__file__).parent.absolute()}/queryes/{{}}.sql"

pgpack_dumper-0.1.2/pgpack_dumper/query_template.py

@@ -0,0 +1,10 @@
+from .query_path import query_path
+
+
+def query_template(query_name: str) -> str:
+    """Get query template for his name."""
+
+    path = query_path().format(query_name)
+
+    with open(path, encoding="utf-8") as query:
+        return query.read()

pgpack_dumper-0.1.2/pgpack_dumper/queryes/attributes.sql

@@ -0,0 +1,4 @@
+select json_agg(json_build_array(attnum, json_build_array(attname, atttypid::int4, 
+case when atttypid = 1042 then atttypmod - 4 when atttypid = 1700 then (atttypmod - 4) >> 16 else attlen end,
+case when atttypid = 1700 then (atttypmod - 4) & 65535 else 0 end)))::text::bytea as metadata
+from pg_attribute where attrelid = '{table_name}'::regclass and attnum > 0 and not attisdropped;

pgpack_dumper-0.1.2/pgpack_dumper/queryes/copy_from.sql

@@ -0,0 +1 @@
+copy {table_name} from stdin with (format binary);

pgpack_dumper-0.1.2/pgpack_dumper/queryes/copy_to.sql

@@ -0,0 +1 @@
+copy {table_name} to stdout with (format binary);

pgpack_dumper-0.1.2/pgpack_dumper/queryes/prepare.sql

@@ -0,0 +1,4 @@
+prepare {prepare_name} as {query} limit 0;
+drop table if exists {table_name};
+create temporary table {table_name} as execute {prepare_name} (null);
+deallocate prepare {prepare_name};

pgpack_dumper-0.1.2/pgpack_dumper/queryes/relkind.sql

@@ -0,0 +1 @@
+select relkind from pg_class where oid = '{table_name}'::regclass;

pgpack_dumper-0.1.2/pgpack_dumper/random_name.py

@@ -0,0 +1,7 @@
+from random import randbytes
+
+
+def random_name() -> str:
+    """Generate random name for prepare and temp table."""
+
+    return f"session_{randbytes(8).hex()}"  # noqa: S311

pgpack_dumper-0.1.2/pgpack_dumper/search_object.py

@@ -0,0 +1,13 @@
+from re import match
+
+
+pattern = r"\(select \* from (.*)\)|(.*)"
+
+
+def search_object(table: str, query: str = "") -> str:
+    """Return current string for object."""
+
+    if query:
+        return "query"
+
+    return match(pattern, table).group(1) or table

pgpack_dumper-0.1.2/pgpack_dumper/structs.py

@@ -0,0 +1,34 @@
+from enum import Enum
+from typing import NamedTuple
+
+
+class RelClass(NamedTuple):
+    """Postgres objects."""
+
+    rel_name: str
+    is_readobject: bool
+    is_readable: bool
+
+
+class PGObject(RelClass, Enum):
+    """RelClass object from relkind value."""
+
+    r = RelClass("Relation table", True, True)
+    i = RelClass("Index", False, False)
+    S = RelClass("Sequence", False, False)
+    t = RelClass("Toast table", False, False)
+    v = RelClass("View", False, True)
+    m = RelClass("Materialized view", False, True)
+    c = RelClass("Composite type", False, False)
+    f = RelClass("Foreign table", False, True)
+    p = RelClass("Partitioned table", True, True)
+    I = RelClass("Partitioned index", False, True)  # noqa: E741
+    u = RelClass("Temporary table", True, True)
+    o = RelClass("Optimized files", False, False)
+    b = RelClass("Block directory", False, False)
+    M = RelClass("Visibility map", False, False)
+
+    def __str__(self) -> str:
+        """String representation class."""
+
+        return self.rel_name

pgpack_dumper-0.1.2/pgpack_dumper/version.py

@@ -0,0 +1 @@
+__version__ = "0.1.2"

pgpack_dumper-0.1.2/pgpack_dumper.egg-info/PKG-INFO

@@ -0,0 +1,139 @@
+Metadata-Version: 2.1
+Name: pgpack-dumper
+Version: 0.1.2
+Summary: Library for read and write PGPack format between PostgreSQL and file.
+Home-page: https://github.com/0xMihalich/pgpack_dumper
+Author: 0xMihalich
+Author-email: bayanmobile87@gmail.com
+Description-Content-Type: text/markdown
+License-File: README.md
+License-File: CHANGELOG.md
+Requires-Dist: pgpack==0.1.3
+Requires-Dist: psycopg>=3.2.9
+Requires-Dist: sqlparse>=0.5.3
+
+# PGPackDumper
+
+Library for read and write PGPack format between PostgreSQL and file
+
+## Examples
+
+### Initialization
+
+```python
+from pgpack_dumper import (
+    CompressionMethod,
+    PGConnector,
+    PGPackDumper,
+)
+
+connector = PGConnector(
+    host = <your host>,
+    dbname = <your database>,
+    user = <your username>,
+    password = <your password>,
+    port = <your port>,
+)
+
+dumper = PGPackDumper(
+    connector=connector,
+    compression_method=CompressionMethod.LZ4,  # or CompressionMethod.ZSTD or CompressionMethod.NONE
+)
+```
+
+### Read dump from PostgreSQL into file
+
+```python
+file_name = "pgpack.lz4"
+# you need define one of parameter query or table_name
+query = "select ..."  # some sql query
+table_name = "public.test_table"  # or some table
+
+with open(file_name, "wb") as fileobj:
+    dumper.read_dump(
+        fileobj,
+        query,
+        table_name,
+    )
+```
+
+### Write dump from file into PostgreSQL
+
+```python
+file_name = "pgpack.lz4"
+# you need define one of parameter table_name
+table_name = "public.test_table"  # some table
+
+with open(file_name, "rb") as fileobj:
+    dumper.write_dump(
+        fileobj,
+        table_name,
+    )
+```
+
+### Write from PostgreSQL into PostgreSQL
+
+Same server
+
+```python
+
+table_dest = "public.test_table_write"  # some table for write
+table_src = "public.test_table_read"  # some table for read
+query_src = "select ..."  # or some sql query for read
+
+dumper.write_between(
+    table_dest,
+    table_src,
+    query_src,
+)
+```
+
+Different servers
+
+```python
+
+connector_src = PGConnector(
+    host = <host src>,
+    dbname = <database src>,
+    user = <username src>,
+    password = <password src>,
+    port = <port src>,
+)
+
+dumper_src = PGPackDumper(connector=connector_src)
+
+table_dest = "public.test_table_write"  # some table for write
+table_src = "public.test_table_read"  # some table for read
+query_src = "select ..."  # or some sql query for read
+
+dumper.write_between(
+    table_dest,
+    table_src,
+    query_src,
+    dumper_src.cursor,
+)
+```
+
+### Open PGPack file format
+
+Get info from my another repository https://github.com/0xMihalich/pgpack
+
+## Installation
+
+### From pip
+
+```bash
+pip install pgpack_dumper
+```
+
+### From local directory
+
+```bash
+pip install .
+```
+
+### From git
+
+```bash
+pip install git+https://github.com/0xMihalich/pgpack_dumper
+```

pgpack_dumper-0.1.2/pgpack_dumper.egg-info/SOURCES.txt

@@ -0,0 +1,32 @@
+CHANGELOG.md
+MANIFEST.in
+README.md
+pyproject.toml
+requirements.txt
+setup.cfg
+setup.py
+pgpack_dumper/__init__.py
+pgpack_dumper/connector.py
+pgpack_dumper/copy.py
+pgpack_dumper/dumper.py
+pgpack_dumper/errors.py
+pgpack_dumper/logger.py
+pgpack_dumper/metadata.py
+pgpack_dumper/multiquery.py
+pgpack_dumper/query_path.py
+pgpack_dumper/query_template.py
+pgpack_dumper/random_name.py
+pgpack_dumper/search_object.py
+pgpack_dumper/structs.py
+pgpack_dumper/version.py
+pgpack_dumper.egg-info/PKG-INFO
+pgpack_dumper.egg-info/SOURCES.txt
+pgpack_dumper.egg-info/dependency_links.txt
+pgpack_dumper.egg-info/not-zip-safe
+pgpack_dumper.egg-info/requires.txt
+pgpack_dumper.egg-info/top_level.txt
+pgpack_dumper/queryes/attributes.sql
+pgpack_dumper/queryes/copy_from.sql
+pgpack_dumper/queryes/copy_to.sql
+pgpack_dumper/queryes/prepare.sql
+pgpack_dumper/queryes/relkind.sql

pgpack_dumper-0.1.2/pgpack_dumper.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

pgpack_dumper-0.1.2/pgpack_dumper.egg-info/not-zip-safe

@@ -0,0 +1 @@
+

pgpack_dumper-0.1.2/pgpack_dumper.egg-info/requires.txt

@@ -0,0 +1,3 @@
+pgpack==0.1.3
+psycopg>=3.2.9
+sqlparse>=0.5.3

pgpack_dumper-0.1.2/pgpack_dumper.egg-info/top_level.txt

@@ -0,0 +1 @@
+pgpack_dumper

pgpack_dumper-0.1.2/pyproject.toml

@@ -0,0 +1,3 @@
+[build-system]
+requires = ["setuptools >= 42.0.0"]
+build-backend = "setuptools.build_meta"

pgpack_dumper-0.1.2/requirements.txt

@@ -0,0 +1,3 @@
+pgpack==0.1.3
+psycopg>=3.2.9
+sqlparse>=0.5.3

pgpack_dumper-0.1.2/setup.cfg

@@ -0,0 +1,14 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+
+[metadata]
+license_files = README.md, CHANGELOG.md
+
+[options]
+install_requires = file: requirements.txt
+
+[options.package_data]
+* = 
+	queryes/*.sql
+

pgpack_dumper-0.1.2/setup.py

@@ -0,0 +1,31 @@
+import shutil
+from setuptools import (
+    find_packages,
+    setup,
+)
+
+shutil.rmtree("build", ignore_errors=True)
+shutil.rmtree("pgpack.egg-info", ignore_errors=True)
+
+with open(file="README.md", encoding="utf-8") as f:
+    long_description = f.read()
+
+setup(
+    name="pgpack_dumper",
+    version="0.1.2",
+    packages=find_packages(),
+    author="0xMihalich",
+    author_email="bayanmobile87@gmail.com",
+    description=(
+        "Library for read and write PGPack "
+        "format between PostgreSQL and file."
+    ),
+    url="https://github.com/0xMihalich/pgpack_dumper",
+    long_description=long_description,
+    long_description_content_type="text/markdown",
+    zip_safe=False,
+    package_data={
+        "pgpack_dumper.queryes": ["*.sql"],
+    },
+    include_package_data=True,
+)