pgsync 5.0.0__tar.gz → 6.0.0__tar.gz

{pgsync-5.0.0 → pgsync-6.0.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pgsync
-Version: 5.0.0
+Version: 6.0.0
 Summary: Postgres/MySQL/MariaDB to Elasticsearch/OpenSearch sync
 Home-page: https://github.com/toluaina/pgsync
 Author: Tolu Aina
@@ -22,6 +22,7 @@ Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
 Classifier: Programming Language :: Python :: Implementation :: CPython
 Classifier: Programming Language :: Python :: Implementation :: PyPy
 Classifier: License :: OSI Approved :: MIT License
@@ -32,17 +33,17 @@ License-File: LICENSE
 License-File: AUTHORS.rst
 Requires-Dist: async-timeout==5.0.1
 Requires-Dist: backports-datetime-fromisoformat==2.0.3
-Requires-Dist: boto3==1.40.50
-Requires-Dist: botocore==1.40.50
+Requires-Dist: boto3==1.40.64
+Requires-Dist: botocore==1.40.64
 Requires-Dist: certifi==2025.10.5
-Requires-Dist: charset-normalizer==3.4.3
+Requires-Dist: charset-normalizer==3.4.4
 Requires-Dist: click==8.1.8
 Requires-Dist: elastic-transport==9.1.0
 Requires-Dist: elasticsearch==7.17.12
 Requires-Dist: elasticsearch-dsl==7.4.1
-Requires-Dist: environs==14.3.0
+Requires-Dist: environs==14.4.0
 Requires-Dist: events==0.5
-Requires-Dist: idna==3.10
+Requires-Dist: idna==3.11
 Requires-Dist: jmespath==1.0.1
 Requires-Dist: marshmallow==4.0.1
 Requires-Dist: mysql-replication==1.0.9
@@ -52,8 +53,8 @@ Requires-Dist: packaging==25.0
 Requires-Dist: psycopg2-binary==2.9.11
 Requires-Dist: pymysql==1.1.2
 Requires-Dist: python-dateutil==2.9.0.post0
-Requires-Dist: python-dotenv==1.1.1
-Requires-Dist: redis==6.4.0
+Requires-Dist: python-dotenv==1.2.1
+Requires-Dist: redis==7.0.1
 Requires-Dist: requests==2.32.5
 Requires-Dist: requests-aws4auth==1.3.1
 Requires-Dist: s3transfer==0.14.0

{pgsync-5.0.0 → pgsync-6.0.0}/README.md

@@ -5,6 +5,7 @@
 [![Python versions](https://img.shields.io/pypi/pyversions/pgsync)](https://pypi.org/project/pgsync)
 [![Downloads](https://img.shields.io/pypi/dm/pgsync)](https://pypi.org/project/pgsync)
 [![codecov](https://codecov.io/gh/toluaina/pgsync/branch/main/graph/badge.svg?token=cvQzYkz6CV)](https://codecov.io/gh/toluaina/pgsync)
+[![Sponsored by DigitalOcean](https://img.shields.io/badge/Sponsored%20by-DigitalOcean-0080FF?logo=digitalocean&logoColor=white)](https://www.digitalocean.com/?utm_medium=opensource&utm_source=pgsync)
 
 
 ## PostgreSQL/MySQL/MariaDB to Elasticsearch/OpenSearch sync
@@ -43,6 +44,23 @@ Other benefits of PGSync include:
 - Scale on-demand (multiple consumers)
 - Easily join multiple nested tables
 
+## Sponsors
+
+[PGSync](https://pgsync.com) is made possible with support from [DigitalOcean](https://www.digitalocean.com/?utm_medium=opensource&utm_source=pgsync).
+
+<p>
+  <a href="https://www.digitalocean.com/?utm_medium=opensource&utm_source=pgsync" rel="sponsored noopener noreferrer">
+    <img
+      src="https://opensource.nyc3.cdn.digitaloceanspaces.com/attribution/assets/SVG/DO_Logo_horizontal_blue.svg"
+      alt="DigitalOcean"
+      width="210"
+      loading="lazy"
+      decoding="async"
+    >
+  </a>
+</p>
+
+
 #### Why?
 
 At a high level, you have data in a PostgreSQL/MySQL/MariaDB database and you want to mirror it in Elasticsearch/OpenSearch.  
@@ -91,6 +109,14 @@ There are several ways of installing and trying PGSync
  - [Running in Docker](#running-in-docker) is the easiest way to get up and running.
  - [Manual configuration](#manual-configuration) 
 
+#### Book Demo Example (requires a DigitalOcean account)
+
+[![Deploy to DO](https://www.deploytodo.com/do-btn-blue.svg)](https://cloud.digitalocean.com/apps/new?repo=https://github.com/toluaina/pgsync/tree/main)
+
+Fill in the following during the setup
+ - `ELASTICSEARCH_URL` e.g. https://user:pass@os-host:443
+ - `REDIS_URL` e.g. rediss://default:pass@host:port/0
+
 
 ##### Running in Docker (Using Github Repository)
 

{pgsync-5.0.0 → pgsync-6.0.0}/bin/bootstrap

@@ -26,7 +26,16 @@ logger = logging.getLogger(__name__)
     default=settings.SCHEMA,
     show_default=True,
     cls=MutuallyExclusiveOption,
-    mutually_exclusive=["s3_schema_url"],
+    mutually_exclusive=["s3_schema_url", "schema_url"],
+)
+@click.option(
+    "--schema_url",
+    help="URL for schema config",
+    type=click.STRING,
+    default=settings.SCHEMA_URL,
+    show_default=True,
+    cls=MutuallyExclusiveOption,
+    mutually_exclusive=["config", "s3_schema_url"],
 )
 @click.option(
     "--s3_schema_url",
@@ -35,7 +44,7 @@ logger = logging.getLogger(__name__)
     default=settings.S3_SCHEMA_URL,
     show_default=True,
     cls=MutuallyExclusiveOption,
-    mutually_exclusive=["config"],
+    mutually_exclusive=["config", "schema_url"],
 )
 @click.option("--host", "-h", help="PG_HOST override")
 @click.option("--password", is_flag=True, help="Prompt for database password")
@@ -67,6 +76,7 @@ logger = logging.getLogger(__name__)
 def main(
     teardown: bool,
     config: str,
+    schema_url: str,
     s3_schema_url: str,
     user: str,
     password: bool,
@@ -89,13 +99,24 @@ def main(
         )
     kwargs = {key: value for key, value in kwargs.items() if value is not None}
 
-    validate_config(config=config, s3_schema_url=s3_schema_url)
+    validate_config(
+        config=config,
+        schema_url=schema_url,
+        s3_schema_url=s3_schema_url,
+    )
 
-    show_settings(config=config, s3_schema_url=s3_schema_url)
+    show_settings(
+        config=config,
+        schema_url=schema_url,
+        s3_schema_url=s3_schema_url,
+        **kwargs,
+    )
 
     validate: bool = False if teardown else True
 
-    for doc in config_loader(config=config, s3_schema_url=s3_schema_url):
+    for doc in config_loader(
+        config=config, schema_url=schema_url, s3_schema_url=s3_schema_url
+    ):
         sync: Sync = Sync(
             doc,
             verbose=verbose,

{pgsync-5.0.0 → pgsync-6.0.0}/bin/parallel_sync

@@ -53,7 +53,13 @@ from threading import Thread
 import click
 import sqlalchemy as sa
 
-from pgsync.settings import BLOCK_SIZE, CHECKPOINT_PATH, S3_SCHEMA_URL, SCHEMA
+from pgsync.settings import (
+    BLOCK_SIZE,
+    CHECKPOINT_PATH,
+    S3_SCHEMA_URL,
+    SCHEMA,
+    SCHEMA_URL,
+)
 from pgsync.sync import Sync
 from pgsync.utils import (
     config_loader,
@@ -386,7 +392,16 @@ def run_task(
     default=SCHEMA,
     show_default=True,
     cls=MutuallyExclusiveOption,
-    mutually_exclusive=["s3_schema_url"],
+    mutually_exclusive=["s3_schema_url", "schema_url"],
+)
+@click.option(
+    "--schema_url",
+    help="URL for schema config",
+    type=click.STRING,
+    default=SCHEMA_URL,
+    show_default=True,
+    cls=MutuallyExclusiveOption,
+    mutually_exclusive=["config", "s3_schema_url"],
 )
 @click.option(
     "--s3_schema_url",
@@ -395,7 +410,7 @@ def run_task(
     default=S3_SCHEMA_URL,
     show_default=True,
     cls=MutuallyExclusiveOption,
-    mutually_exclusive=["config"],
+    mutually_exclusive=["config", "schema_url"],
 )
 @click.option(
     "--verbose",
@@ -428,7 +443,12 @@ def run_task(
     default="multiprocess_async",
 )
 def main(
-    config: str, s3_schema_url: str, nprocs: int, mode: str, verbose: bool
+    config: str,
+    schema_url: str,
+    s3_schema_url: str,
+    nprocs: int,
+    mode: str,
+    verbose: bool,
 ) -> None:
     """
     TODO:
@@ -436,11 +456,17 @@ def main(
     - Handle KeyboardInterrupt Exception
     """
 
-    validate_config(config=config, s3_schema_url=s3_schema_url)
+    validate_config(
+        config=config, schema_url=schema_url, s3_schema_url=s3_schema_url
+    )
 
-    show_settings(config=config, s3_schema_url=s3_schema_url)
+    show_settings(
+        config=config, schema_url=schema_url, s3_schema_url=s3_schema_url
+    )
 
-    for doc in config_loader(config=config, s3_schema_url=s3_schema_url):
+    for doc in config_loader(
+        config=config, schema_url=schema_url, s3_schema_url=s3_schema_url
+    ):
         tasks: t.Generator = fetch_tasks(doc)
         if mode == "synchronous":
             synchronous(tasks, doc, verbose=verbose)

{pgsync-5.0.0 → pgsync-6.0.0}/pgsync/__init__.py

@@ -2,4 +2,4 @@
 
 __author__ = "Tolu Aina"
 __email__ = "tolu@pgsync.com"
-__version__ = "5.0.0"
+__version__ = "6.0.0"

{pgsync-5.0.0 → pgsync-6.0.0}/pgsync/base.py

@@ -31,6 +31,8 @@ from .exc import (
 )
 from .settings import (
     IS_MYSQL_COMPAT,
+    MYSQL_DATABASE,
+    PG_DATABASE,
     PG_HOST_RO,
     PG_PASSWORD_RO,
     PG_PORT_RO,
@@ -39,6 +41,12 @@ from .settings import (
     PG_URL_RO,
     PG_USER_RO,
     QUERY_CHUNK_SIZE,
+    SQLALCHEMY_MAX_OVERFLOW,
+    SQLALCHEMY_POOL_PRE_PING,
+    SQLALCHEMY_POOL_RECYCLE,
+    SQLALCHEMY_POOL_SIZE,
+    SQLALCHEMY_POOL_TIMEOUT,
+    SQLALCHEMY_USE_NULLPOOL,
     STREAM_RESULTS,
 )
 from .trigger import CREATE_TRIGGER_TEMPLATE
@@ -230,6 +238,7 @@ class Base(object):
         self.__columns: dict = {}
         self.verbose: bool = verbose
         self._conn = None
+        self._session = None
 
     def connect(self) -> None:
         """Connect to database."""
@@ -338,8 +347,19 @@ class Base(object):
 
     @property
     def session(self) -> sessionmaker:
-        Session = sessionmaker(bind=self.engine.connect(), autoflush=True)
-        return Session()
+        if self._session is None:
+            Session = sessionmaker(bind=self.engine, autoflush=True)
+            self._session = Session()
+        return self._session
+
+    def close_session(self) -> None:
+        """Close the cached session and reset it."""
+        if self._session is not None:
+            try:
+                self._session.close()
+            except Exception:
+                pass
+            self._session = None
 
     @property
     def engine(self) -> sa.engine.Engine:
@@ -822,6 +842,7 @@ class Base(object):
         schema: str,
         tables: t.Set,
         user_defined_fkey_tables: dict,
+        node_columns: dict,
     ) -> None:
         create_view(
             self.engine,
@@ -832,6 +853,7 @@ class Base(object):
             tables,
             user_defined_fkey_tables,
             self._materialized_views(schema),
+            node_columns,
         )
 
     def drop_view(self, schema: str) -> None:
@@ -946,9 +968,9 @@ class Base(object):
         """Check if the trigger function exists."""
         return self.exists(
             sa.text(
-                f"SELECT 1 FROM pg_proc WHERE proname = :name "
-                f"AND pronamespace = (SELECT oid FROM pg_namespace "
-                f"WHERE nspname = :schema)"
+                "SELECT 1 FROM pg_proc WHERE proname = :name "
+                "AND pronamespace = (SELECT oid FROM pg_namespace "
+                "WHERE nspname = :schema)"
             ).bindparams(name=TRIGGER_FUNC, schema=schema),
         )
 
@@ -989,7 +1011,7 @@ class Base(object):
             self.disable_trigger(schema, table)
             logger.debug(f"Disabled trigger on table: {schema}.{table}")
 
-    def enable_trigger(self, schema: str, table, str) -> None:
+    def enable_trigger(self, schema: str, table: str) -> None:
         """Enable a pgsync defined trigger."""
         for name in ("notify", "truncate"):
             self.execute(
@@ -1107,20 +1129,21 @@ class Base(object):
         # including trailing space below is deliberate
         suffix: str = f"{row[span[1]:]} "
 
-        if "old-key" and "new-tuple" in suffix:
+        if "old-key" in suffix and "new-tuple" in suffix:
             # this can only be an UPDATE operation
             if payload.tg_op != UPDATE:
                 msg = f"Unknown {payload.tg_op} operation for row: {row}"
                 raise LogicalSlotParseError(msg)
 
-            i: int = suffix.index("old-key:")
+            i: int = suffix.find("old-key:")
             if i > -1:
-                j: int = suffix.index("new-tuple:")
-                s: str = suffix[i + len("old-key:") : j]
-                for key, value in _parse_logical_slot(s):
-                    payload.old[key] = value
+                j: int = suffix.find("new-tuple:")
+                if j > -1:
+                    s: str = suffix[i + len("old-key:") : j]
+                    for key, value in _parse_logical_slot(s):
+                        payload.old[key] = value
 
-            i = suffix.index("new-tuple:")
+            i = suffix.find("new-tuple:")
             if i > -1:
                 s = suffix[i + len("new-tuple:") :]
                 for key, value in _parse_logical_slot(s):
@@ -1336,7 +1359,28 @@ def _pg_engine(
             password=password,
             port=port,
         )
-    return sa.create_engine(url, echo=echo, connect_args=connect_args)
+
+    # Use NullPool for testing to avoid connection exhaustion
+    if SQLALCHEMY_USE_NULLPOOL:
+        from sqlalchemy.pool import NullPool
+
+        return sa.create_engine(
+            url,
+            echo=echo,
+            connect_args=connect_args,
+            poolclass=NullPool,
+        )
+
+    return sa.create_engine(
+        url,
+        echo=echo,
+        connect_args=connect_args,
+        pool_size=SQLALCHEMY_POOL_SIZE,
+        max_overflow=SQLALCHEMY_MAX_OVERFLOW,
+        pool_pre_ping=SQLALCHEMY_POOL_PRE_PING,
+        pool_recycle=SQLALCHEMY_POOL_RECYCLE,
+        pool_timeout=SQLALCHEMY_POOL_TIMEOUT,
+    )
 
 
 def pg_execute(
@@ -1367,7 +1411,7 @@ def create_database(database: str, echo: bool = False) -> None:
     """Create a database."""
     logger.debug(f"Creating database: {database}")
     with pg_engine(
-        "information_schema" if IS_MYSQL_COMPAT else "postgres",
+        MYSQL_DATABASE if IS_MYSQL_COMPAT else PG_DATABASE,
         echo=echo,
     ) as engine:
         pg_execute(
@@ -1382,8 +1426,7 @@ def drop_database(database: str, echo: bool = False) -> None:
     """Drop a database."""
     logger.debug(f"Dropping database: {database}")
     with pg_engine(
-        "information_schema" if IS_MYSQL_COMPAT else "postgres",
-        echo=echo,
+        MYSQL_DATABASE if IS_MYSQL_COMPAT else PG_DATABASE, echo=echo
     ) as engine:
         pg_execute(
             engine,
@@ -1396,7 +1439,7 @@ def drop_database(database: str, echo: bool = False) -> None:
 def database_exists(database: str, echo: bool = False) -> bool:
     """Check if database is present."""
     with pg_engine(
-        "information_schema" if IS_MYSQL_COMPAT else "postgres",
+        MYSQL_DATABASE if IS_MYSQL_COMPAT else PG_DATABASE,
         echo=echo,
     ) as engine:
         with engine.connect() as conn:

{pgsync-5.0.0 → pgsync-6.0.0}/pgsync/constants.py

@@ -135,6 +135,7 @@ ELASTICSEARCH_MAPPING_PARAMETERS = [
     "boost",
     "coerce",
     "copy_to",
+    "dimension",
     "doc_values",
     "dynamic",
     "eager_global_ordinals",
@@ -198,6 +199,7 @@ MATERIALIZED_VIEW_COLUMNS = [
     "indices",
     "primary_keys",
     "table_name",
+    "columns",
 ]
 
 # Primary key delimiter

{pgsync-5.0.0 → pgsync-6.0.0}/pgsync/helper.py

@@ -20,6 +20,7 @@ def teardown(
     drop_index: bool = True,
     delete_checkpoint: bool = True,
     config: t.Optional[str] = None,
+    schema_url: t.Optional[str] = None,
     s3_schema_url: t.Optional[str] = None,
     validate: bool = False,
 ) -> None:
@@ -33,11 +34,17 @@ def teardown(
         drop_index (bool, optional): Whether to drop the index. Defaults to True.
         delete_checkpoint (bool, optional): Whether to delete the checkpoint. Defaults to True.
         config (Optional[str], optional): The configuration file path. Defaults to None.
+        schema_url (Optional[str], optional): The schema URL. Defaults to None.
+        s3_schema_url (Optional[str], optional): The S3 schema URL. Defaults to
         validate (bool, optional): Whether to validate the configuration. Defaults to False.
     """
-    validate_config(config=config, s3_schema_url=s3_schema_url)
+    validate_config(
+        config=config, schema_url=schema_url, s3_schema_url=s3_schema_url
+    )
 
-    for doc in config_loader(config=config, s3_schema_url=s3_schema_url):
+    for doc in config_loader(
+        config=config, schema_url=schema_url, s3_schema_url=s3_schema_url
+    ):
         if not database_exists(doc["database"]):
             logger.warning(f'Database {doc["database"]} does not exist')
             continue

{pgsync-5.0.0 → pgsync-6.0.0}/pgsync/node.py

@@ -294,7 +294,7 @@ class Node(object):
                 self.columns.append(self.model.c[column_name])
 
     @property
-    def primary_keys(self):
+    def primary_keys(self) -> t.List[sa.sql.ColumnElement]:
         return [
             self.model.c[str(sa.text(primary_key))]
             for primary_key in self.model.primary_keys
@@ -311,7 +311,7 @@ class Node(object):
 
     def add_child(self, node: Node) -> None:
         """All nodes except the root node must have a relationship defined."""
-        node.parent: Node = self
+        node.parent = self
         if not node.is_root and (
             not node.relationship.type or not node.relationship.variant
         ):
@@ -388,7 +388,9 @@ class Tree(threading.local):
             raise TableNotInNodeError(f"Table not specified in node: {nodes}")
 
         if not set(nodes.keys()).issubset(set(NODE_ATTRIBUTES)):
-            attrs = set(nodes.keys()).difference(set(NODE_ATTRIBUTES))
+            attrs: t.Set[str] = set(nodes.keys()).difference(
+                set(NODE_ATTRIBUTES)
+            )
             raise NodeAttributeError(f"Unknown node attribute(s): {attrs}")
 
         node: Node = Node(

{pgsync-5.0.0 → pgsync-6.0.0}/pgsync/plugin.py

@@ -16,7 +16,7 @@ class Plugin(ABC):
     """Plugin base class."""
 
     @abstractmethod
-    def transform(self, doc: dict, **kwargs) -> dict:
+    def transform(self, doc: dict, **kwargs: t.Any) -> dict:
         """This must be implemented by all derived classes."""
         pass
 
@@ -90,7 +90,7 @@ class Plugins(object):
             ]:
                 self.walk(f"{package}.{pkg}")
 
-    def transform(self, docs: list) -> t.Generator:
+    def transform(self, docs: t.Iterable[dict]) -> t.Generator:
         """Applies all plugins to each doc."""
         for doc in docs:
             for plugin in self.plugins:

{pgsync-5.0.0 → pgsync-6.0.0}/pgsync/redisqueue.py

@@ -69,10 +69,15 @@ class RedisQueue(object):
             return []
         payloads = [json.loads(i) for i in items]
         visible_map: dict = pg_visible_in_snapshot()(
-            [payload["xmin"] for payload in payloads]
+            [payload.get("xmin") for payload in payloads if "xmin" in payload]
         )
         visible: t.List[dict] = []
         for item, payload in zip(items, payloads):
+            if "xmin" not in payload:
+                logger.warning(
+                    f"Skipping payload without 'xmin' key: {payload}"
+                )
+                continue
             if visible_map.get(payload["xmin"]):
                 # Claim atomically
                 removed = self.__db.lrem(self.key, 1, item)
@@ -80,7 +85,7 @@ class RedisQueue(object):
                     visible.append(payload)
         return visible
 
-    def push(self, items: t.List) -> None:
+    def push(self, items: t.Iterable[dict]) -> None:
         """Push multiple items onto the queue."""
         self.__db.rpush(self.key, *map(json.dumps, items))
 
@@ -97,5 +102,5 @@ class RedisQueue(object):
 
     def get_meta(self, default: t.Any = None) -> t.Any:
         """Retrieve the stored value (or *default* if nothing is set)."""
-        raw = self.__db.get(self._meta_key)
+        raw: t.Optional[str] = self.__db.get(self._meta_key)
         return json.loads(raw) if raw is not None else default

{pgsync-5.0.0 → pgsync-6.0.0}/pgsync/settings.py

@@ -45,12 +45,27 @@ REPLICATION_SLOT_CLEANUP_INTERVAL = env.float(
 # path to the application schema config
 SCHEMA = env.str("SCHEMA", default=None)
 S3_SCHEMA_URL = env.str("S3_SCHEMA_URL", default=None)
+SCHEMA_URL = env.str("SCHEMA_URL", default=None)
 USE_ASYNC = env.bool("USE_ASYNC", default=False)
 STREAM_RESULTS = env.bool("STREAM_RESULTS", default=True)
 # db polling interval
 POLL_INTERVAL = env.float("POLL_INTERVAL", default=0.1)
 FORMAT_WITH_COMMAS = env.bool("FORMAT_WITH_COMMAS", default=True)
 
+# SQLAlchemy Settings:
+# Use NullPool (no connection pooling) - useful for testing or when you want to close connections immediately
+SQLALCHEMY_USE_NULLPOOL = env.bool("SQLALCHEMY_USE_NULLPOOL", default=False)
+# This is the number of connections that will be persistently maintained in the pool.
+SQLALCHEMY_POOL_SIZE = env.int("SQLALCHEMY_POOL_SIZE", default=5)
+# This is the number of connections that can be opened beyond the pool_size when all connections in the pool are in use.
+SQLALCHEMY_MAX_OVERFLOW = env.int("SQLALCHEMY_MAX_OVERFLOW", default=10)
+# When set to True, a "ping" will be performed on connections before they are checked out of the pool to ensure they are still live.
+SQLALCHEMY_POOL_PRE_PING = env.bool("SQLALCHEMY_POOL_PRE_PING", default=False)
+# This means connections are not recycled based on a timeout. If set to a positive integer, connections will be recycled after that many seconds. For example, 3600 recycles connections after one hour.
+SQLALCHEMY_POOL_RECYCLE = env.int("SQLALCHEMY_POOL_RECYCLE", default=-1)
+# This is the number of seconds to wait for a connection to become available from the pool before raising a TimeoutError.
+SQLALCHEMY_POOL_TIMEOUT = env.int("SQLALCHEMY_POOL_TIMEOUT", default=30)
+
 # Elasticsearch/OpenSearch:
 ELASTICSEARCH_API_KEY = env.str("ELASTICSEARCH_API_KEY", default=None)
 ELASTICSEARCH_API_KEY_ID = env.str("ELASTICSEARCH_API_KEY_ID", default=None)
@@ -187,6 +202,9 @@ if PG_URL:
 else:
     # If PG_URL is not set, we need to use the other PG_* variables
     PG_USER = env.str("PG_USER")
+# The default database name e.g postges or defaultdb
+PG_DATABASE = env.str("PG_DATABASE", default="postgres")
+MYSQL_DATABASE = env.str("MYSQL_DATABASE", default="information_schema")
 
 # Read-only Postgres:
 # This is used for read-only consumers that do not require replication slots or triggers.

{pgsync-5.0.0 → pgsync-6.0.0}/pgsync/singleton.py

@@ -14,7 +14,7 @@ class Singleton(type):
 
     _instances: dict = {}
 
-    def __call__(cls, *args, **kwargs):
+    def __call__(cls, *args: t.Any, **kwargs: t.Any) -> t.Any:
         """
         If an instance of the class has already been created with the same arguments,
         return that instance. Otherwise, create a new instance and return it.