pgbelt 0.8.3__tar.gz → 0.9.3__tar.gz

{pgbelt-0.8.3 → pgbelt-0.9.3}/PKG-INFO

@@ -1,21 +1,20 @@
-Metadata-Version: 2.3
+Metadata-Version: 2.4
 Name: pgbelt
-Version: 0.8.3
+Version: 0.9.3
 Summary: A CLI tool used to manage Postgres data migrations from beginning to end, for a single database or a fleet, leveraging pglogical replication.
+License-File: LICENSE
 Author: Varjitt Jeeva
 Author-email: varjitt.jeeva@autodesk.com
-Requires-Python: >=3.9,<4.0
+Requires-Python: >=3.12,<4.0
 Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.9
-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
 Requires-Dist: aiofiles (>=0.8,<24.2)
-Requires-Dist: asyncpg (>=0.27,<0.31)
+Requires-Dist: asyncpg (>=0.27,<0.32)
 Requires-Dist: pydantic (>=2.0,<3.0)
 Requires-Dist: tabulate (>=0.9.0,<0.10.0)
-Requires-Dist: typer (>=0.9,<0.16)
+Requires-Dist: typer (>=0.9,<0.22)
 Description-Content-Type: text/markdown
 
 # Pgbelt

{pgbelt-0.8.3 → pgbelt-0.9.3}/pgbelt/cmd/preflight.py

@@ -12,44 +12,47 @@ from typer import echo
 from typer import style
 
 
-def _summary_table(results: dict, compared_extensions: list[str] = None) -> list[list]:
+def _summary_table(
+    results: list[dict], compared_results: list[dict] | None = None
+) -> list[list]:
     """
     Takes a dict of precheck results for all databases and returns a summary table for echo.
 
     The summary table alters slightly if the results are for a destination database.
 
-    results format:
-    [
-        {
-            "server_version": "9.6.20",
-            "max_replication_slots": "10",
-            "max_worker_processes": "10",
-            "max_wal_senders": "10",
-            "shared_preload_libraries": ["pg_stat_statements", ...],
-            "rds.logical_replication": "on",
-            "schema: "public",
-            "extensions": ["uuid-ossp", ...],
-            "users": { // See pgbelt.util.postgres.precheck_info results["users"] for more info.
-                "root": {
-                    "rolname": "root",
-                    "rolcanlogin": True,
-                    "rolcreaterole": True,
-                    "rolinherit": True,
-                    "rolsuper": True,
-                    "memberof": ["rds_superuser", ...]
-                },
-                "owner": {
-                    "rolname": "owner",
-                    "rolcanlogin": True,
-                    "rolcreaterole": False,
-                    "rolinherit": True,
-                    "rolsuper": False,
-                    "memberof": ["rds_superuser", ...]
+    Example results format::
+
+        [
+            {
+                "server_version": "9.6.20",
+                "max_replication_slots": "10",
+                "max_worker_processes": "10",
+                "max_wal_senders": "10",
+                "shared_preload_libraries": ["pg_stat_statements", ...],
+                "rds.logical_replication": "on",
+                "schema: "public",
+                "extensions": ["uuid-ossp", ...],
+                "users": { // See pgbelt.util.postgres.precheck_info results["users"] for more info.
+                    "root": {
+                        "rolname": "root",
+                        "rolcanlogin": True,
+                        "rolcreaterole": True,
+                        "rolinherit": True,
+                        "rolsuper": True,
+                        "memberof": ["rds_superuser", ...]
+                    },
+                    "owner": {
+                        "rolname": "owner",
+                        "rolcanlogin": True,
+                        "rolcreaterole": False,
+                        "rolinherit": True,
+                        "rolsuper": False,
+                        "memberof": ["rds_superuser", ...]
+                    }
                 }
-            }
-        },
-        ...
-    ]
+            },
+            ...
+        ]
     """
 
     summary_table = [
@@ -69,6 +72,11 @@ def _summary_table(results: dict, compared_extensions: list[str] = None) -> list
     ]
 
     results.sort(key=lambda d: d["db"])
+    compared_by_db = (
+        {entry["db"]: entry for entry in compared_results}
+        if compared_results is not None
+        else {}
+    )
 
     for r in results:
         root_ok = (
@@ -80,9 +88,9 @@ def _summary_table(results: dict, compared_extensions: list[str] = None) -> list
             or r["users"]["root"]["rolsuper"]
         )
 
-        # Interestingly enough, we can tell if this is being run for a destination database if the compared_extensions is not None.
+        # Interestingly enough, we can tell if this is being run for a destination database if the compared_results is not None.
         # This is because it is only set when we are ensuring all source extensions are in the destination.
-        is_dest_db = compared_extensions is not None
+        is_dest_db = compared_results is not None
 
         # If this is a destination database, we need to check if the owner can create objects.
 
@@ -149,9 +157,13 @@ def _summary_table(results: dict, compared_extensions: list[str] = None) -> list
         # If this is a destinatino DB, we are ensuring all source extensions are in the destination.
         # If not, we don't want this column in the table.
         if is_dest_db:
+            compare_entry = compared_by_db.get(r["db"])
+            if compare_entry is None:
+                summary_table[-1].append(style(False, "red"))
+                continue
             extensions_ok = all(
-                [e in r["extensions"] for e in compared_extensions]
-            ) and all([e in compared_extensions for e in r["extensions"]])
+                [e in r["extensions"] for e in compare_entry["extensions"]]
+            ) and all([e in compare_entry["extensions"] for e in r["extensions"]])
             summary_table[-1].append(
                 style(extensions_ok, "green" if extensions_ok else "red")
             )
@@ -165,25 +177,26 @@ def _users_table(users: dict, is_dest_db: bool = False) -> list[list]:
 
     The users table alters slightly if the results are for a destination database.
 
-    users format:
-    {
-        "root": {
-            "rolname": "root",
-            "rolcanlogin": True,
-            "rolcreaterole": True,
-            "rolinherit": True,
-            "rolsuper": True,
-            "memberof": ["rds_superuser", ...]
-        },
-        "owner": {
-            "rolname": "owner",
-            "rolcanlogin": True,
-            "rolcreaterole": False,
-            "rolinherit": True,
-            "rolsuper": False,
-            "memberof": ["rds_superuser", ...]
+    Example users format::
+
+        {
+            "root": {
+                "rolname": "root",
+                "rolcanlogin": True,
+                "rolcreaterole": True,
+                "rolinherit": True,
+                "rolsuper": True,
+                "memberof": ["rds_superuser", ...]
+            },
+            "owner": {
+                "rolname": "owner",
+                "rolcanlogin": True,
+                "rolcreaterole": False,
+                "rolinherit": True,
+                "rolsuper": False,
+                "memberof": ["rds_superuser", ...]
+            }
         }
-    }
 
     See pgbelt.util.postgres.precheck_info results["users"] for more info..
     """
@@ -250,15 +263,16 @@ def _tables_table(
     """
     Takes a list of table dicts and returns a table of the tables for echo.
 
-    tables format:
-    [
-        {
-            "Name": "table_name",
-            "Schema": "schema_name",
-            "Owner": "owner_name"
-        },
-        ...
-    ]
+    Example tables format::
+
+        [
+            {
+                "Name": "table_name",
+                "Schema": "schema_name",
+                "Owner": "owner_name"
+            },
+            ...
+        ]
     """
 
     tables_table = [
@@ -297,15 +311,16 @@ def _sequences_table(
     """
     Takes a list of sequence dicts and returns a table of the sequences for echo.
 
-    sequences format:
-    [
-        {
-            "Name": "sequence_name",
-            "Schema": "schema_name",
-            "Owner": "owner_name"
-        },
-        ...
-    ]
+    Example sequences format::
+
+        [
+            {
+                "Name": "sequence_name",
+                "Schema": "schema_name",
+                "Owner": "owner_name"
+            },
+            ...
+        ]
     """
 
     sequences_table = [
@@ -339,11 +354,12 @@ def _extensions_table(
     Takes a list of source and destination extensions and returns a table of the extensions for echo.
     It will flag any extensions that are not in the destination database but are in the source database.
 
-    <source/destination>_extensions format:
-    [
-        "uuid-ossp",
-        ...
-    ]
+    Example extensions format::
+
+        [
+            "uuid-ossp",
+            ...
+        ]
 
     """
 
@@ -374,71 +390,72 @@ async def _print_prechecks(results: list[dict]) -> list[list]:
     If there are multiple databases, only print the summary table.
     If there is only one database, print the summary table and more detailed info.
 
-    results format:
-    [
-        {
-            "db": "db_name",
-            "src": {
-                "server_version": "9.6.20",
-                "max_replication_slots": "10",
-                "max_worker_processes": "10",
-                "max_wal_senders": "10",
-                "pg_stat_statements": "installed",
-                "pglogical": "installed",
-                "rds.logical_replication": "on",
-                "schema: "public",
-                "users": { // See pgbelt.util.postgres.precheck_info results["users"] for more info.
-                    "root": {
-                        "rolname": "root",
-                        "rolcanlogin": True,
-                        "rolcreaterole": True,
-                        "rolinherit": True,
-                        "rolsuper": True,
-                        "memberof": ["rds_superuser", ...]
-                    },
-                    "owner": {
-                        "rolname": "owner",
-                        "rolcanlogin": True,
-                        "rolcreaterole": False,
-                        "rolinherit": True,
-                        "rolsuper": False,
-                        "memberof": ["rds_superuser", ...],
-                        "can_create": True
+    Example results format::
+
+        [
+            {
+                "db": "db_name",
+                "src": {
+                    "server_version": "9.6.20",
+                    "max_replication_slots": "10",
+                    "max_worker_processes": "10",
+                    "max_wal_senders": "10",
+                    "pg_stat_statements": "installed",
+                    "pglogical": "installed",
+                    "rds.logical_replication": "on",
+                    "schema: "public",
+                    "users": { // See pgbelt.util.postgres.precheck_info results["users"] for more info.
+                        "root": {
+                            "rolname": "root",
+                            "rolcanlogin": True,
+                            "rolcreaterole": True,
+                            "rolinherit": True,
+                            "rolsuper": True,
+                            "memberof": ["rds_superuser", ...]
+                        },
+                        "owner": {
+                            "rolname": "owner",
+                            "rolcanlogin": True,
+                            "rolcreaterole": False,
+                            "rolinherit": True,
+                            "rolsuper": False,
+                            "memberof": ["rds_superuser", ...],
+                            "can_create": True
+                        }
                     }
-                }
-            },
-            "dst": {
-                "server_version": "9.6.20",
-                "max_replication_slots": "10",
-                "max_worker_processes": "10",
-                "max_wal_senders": "10",
-                "pg_stat_statements": "installed",
-                "pglogical": "installed",
-                "rds.logical_replication": "on",
-                "schema: "public",
-                "users": { // See pgbelt.util.postgres.precheck_info results["users"] for more info.
-                    "root": {
-                        "rolname": "root",
-                        "rolcanlogin": True,
-                        "rolcreaterole": True,
-                        "rolinherit": True,
-                        "rolsuper": True,
-                        "memberof": ["rds_superuser", ...]
-                    },
-                    "owner": {
-                        "rolname": "owner",
-                        "rolcanlogin": True,
-                        "rolcreaterole": False,
-                        "rolinherit": True,
-                        "rolsuper": False,
-                        "memberof": ["rds_superuser", ...],
-                        "can_create": True
+                },
+                "dst": {
+                    "server_version": "9.6.20",
+                    "max_replication_slots": "10",
+                    "max_worker_processes": "10",
+                    "max_wal_senders": "10",
+                    "pg_stat_statements": "installed",
+                    "pglogical": "installed",
+                    "rds.logical_replication": "on",
+                    "schema: "public",
+                    "users": { // See pgbelt.util.postgres.precheck_info results["users"] for more info.
+                        "root": {
+                            "rolname": "root",
+                            "rolcanlogin": True,
+                            "rolcreaterole": True,
+                            "rolinherit": True,
+                            "rolsuper": True,
+                            "memberof": ["rds_superuser", ...]
+                        },
+                        "owner": {
+                            "rolname": "owner",
+                            "rolcanlogin": True,
+                            "rolcreaterole": False,
+                            "rolinherit": True,
+                            "rolsuper": False,
+                            "memberof": ["rds_superuser", ...],
+                            "can_create": True
+                        }
                     }
                 }
-            }
-        },
-        ...
-    ]
+            },
+            ...
+        ]
     """
 
     src_summaries = []
@@ -448,12 +465,9 @@ async def _print_prechecks(results: list[dict]) -> list[list]:
         dst_summaries.append(r["dst"])
 
     src_summary_table = _summary_table(src_summaries)
-    dst_summary_table = _summary_table(
-        dst_summaries, compared_extensions=r["src"]["extensions"]
-    )
+    dst_summary_table = _summary_table(dst_summaries, compared_results=src_summaries)
 
     if len(results) != 1:
-
         # For mulitple databases, we only print the summary table.
 
         src_multi_display_string = (
@@ -564,7 +578,7 @@ async def _print_prechecks(results: list[dict]) -> list[list]:
     return src_summary_table, dst_summary_table
 
 
-@run_with_configs(skip_dst=True, results_callback=_print_prechecks)
+@run_with_configs(results_callback=_print_prechecks)
 async def precheck(config_future: Awaitable[DbupgradeConfig]) -> dict:
     """
     Report whether your source database meets the basic requirements for pgbelt.

{pgbelt-0.8.3 → pgbelt-0.9.3}/pgbelt/cmd/sync.py

@@ -12,8 +12,9 @@ from pgbelt.util.dump import dump_source_tables
 from pgbelt.util.dump import load_dumped_tables
 from pgbelt.util.logs import get_logger
 from pgbelt.util.postgres import analyze_table_pkeys
-from pgbelt.util.postgres import compare_100_rows
+from pgbelt.util.postgres import compare_100_random_rows
 from pgbelt.util.postgres import compare_latest_100_rows
+from pgbelt.util.postgres import compare_tables_without_pkeys
 from pgbelt.util.postgres import dump_sequences
 from pgbelt.util.postgres import load_sequences
 from pgbelt.util.postgres import run_analyze
@@ -143,10 +144,15 @@ async def validate_data(config_future: Awaitable[DbupgradeConfig]) -> None:
     try:
         logger = get_logger(conf.db, conf.dc, "sync")
         await gather(
-            compare_100_rows(src_pool, dst_pool, conf.tables, conf.schema_name, logger),
+            compare_100_random_rows(
+                src_pool, dst_pool, conf.tables, conf.schema_name, logger
+            ),
             compare_latest_100_rows(
                 src_pool, dst_pool, conf.tables, conf.schema_name, logger
             ),
+            compare_tables_without_pkeys(
+                src_pool, dst_pool, conf.tables, conf.schema_name, logger
+            ),
         )
     finally:
         await gather(*[p.close() for p in pools])
@@ -218,7 +224,7 @@ async def sync(
             )
 
         await gather(
-            compare_100_rows(
+            compare_100_random_rows(
                 src_pool,
                 dst_owner_pool,
                 conf.tables,

{pgbelt-0.8.3 → pgbelt-0.9.3}/pgbelt/util/dump.py

@@ -76,6 +76,47 @@ async def _execute_subprocess(
     return out
 
 
+async def _dump_table(config: DbupgradeConfig, table: str, logger: Logger) -> None:
+    """
+    Dump a single table using pg_dump, strip unwanted lines, and save to file.
+    """
+    command = [
+        "pg_dump",
+        "--data-only",
+        f'--table={config.schema_name}."{table}"',
+        config.src.pglogical_dsn,
+    ]
+
+    out = await _execute_subprocess(command, f"dumped {table}", logger)
+    content = out.decode("utf-8")
+
+    # Strip out unwanted lines, stupid PG17
+    keywords = [
+        "transaction_timeout",
+        # "SET statement_timeout", # This one is fine
+        # "SET lock_timeout", # This one is fine
+        # "SET idle_in_transaction_session_timeout", # This one is fine
+        "SET client_encoding",
+        "SET standard_conforming_strings",
+        "SET check_function_bodies",
+        "SET xmloption",
+        "SET client_min_messages",
+        "SET row_security",
+        "pg_catalog.set_config",  # Stupid search path, this should not be run.
+        "\\restrict",
+        "\\unrestrict",
+    ]
+    lines = content.split("\n")
+    filtered_lines = [
+        line for line in lines if not any(keyword in line for keyword in keywords)
+    ]
+    filtered_content = "\n".join(filtered_lines)
+
+    # Write the filtered content to file
+    async with aopen(table_file(config.db, config.dc, table), "w") as f:
+        await f.write(filtered_content)
+
+
 async def dump_source_tables(
     config: DbupgradeConfig, tables: list[str], logger: Logger
 ) -> None:
@@ -88,21 +129,7 @@ async def dump_source_tables(
 
     dumps = []
     for table in tables:
-        dumps.append(
-            _execute_subprocess(
-                [
-                    "pg_dump",
-                    "--data-only",
-                    f'--table={config.schema_name}."{table}"',
-                    "-Fc",
-                    "-f",
-                    table_file(config.db, config.dc, table),
-                    config.src.pglogical_dsn,
-                ],
-                f"dumped {table}",
-                logger,
-            )
-        )
+        dumps.append(_dump_table(config, table, logger))
 
     await asyncio.gather(*dumps)
 
@@ -137,9 +164,9 @@ async def load_dumped_tables(
         loads.append(
             _execute_subprocess(
                 [
-                    "pg_restore",
-                    "-d",
+                    "psql",
                     config.dst.owner_dsn,
+                    "-f",
                     file,
                 ],
                 f"loaded {file}",
@@ -204,7 +231,7 @@ async def dump_source_schema(config: DbupgradeConfig, logger: Logger) -> None:
         schema_file(config.db, config.dc, NO_INVALID_NO_INDEX), "w"
     ) as out:
         for command in commands:
-            if not ("NOT VALID" in command) and not (
+            if "NOT VALID" not in command and not (
                 "CREATE" in command and "INDEX" in command
             ):
                 await out.write(command)
@@ -305,13 +332,13 @@ async def remove_dst_not_valid_constraints(
         if not regex_matches:
             continue
         table = regex_matches.groupdict()["table"]
-        constraint = table = regex_matches.groupdict()["constraint"]
+        constraint = regex_matches.groupdict()["constraint"]
 
         if (config.tables and table in config.tables) or not config.tables:
             queries = queries + f"ALTER TABLE {table} DROP CONSTRAINT {constraint};"
 
     if queries != "":
-        command = ["psql", config.dst.owner_dsn, "-c", f"'{queries}'"]
+        command = ["psql", config.dst.owner_dsn, "-c", queries]
 
         await _execute_subprocess(
             command, "Finished removing NOT VALID constraints from the target.", logger

{pgbelt-0.8.3 → pgbelt-0.9.3}/pgbelt/util/postgres.py

@@ -214,22 +214,23 @@ async def compare_data(
     )
 
 
-async def compare_100_rows(
+async def compare_100_random_rows(
     src_pool: Pool, dst_pool: Pool, tables: list[str], schema: str, logger: Logger
 ) -> None:
     """
     Validate data between source and destination databases by doing the following:
     1. Get all tables with primary keys
-    2. For each of those tables, select * limit 100
+    2. For each of those tables, select 100 random rows
     3. For each row, ensure the row in the destination is identical
     """
-    logger.info("Comparing 100 rows...")
+    logger.info("Comparing 100 random rows...")
 
     query = """
     SELECT * FROM
     (
         SELECT *
         FROM {table}
+        ORDER BY RANDOM()
         LIMIT 100
     ) AS T1
     ORDER BY {order_by_pkeys};
@@ -259,6 +260,98 @@ async def compare_latest_100_rows(
     await compare_data(src_pool, dst_pool, query, tables, schema, logger)
 
 
+async def compare_tables_without_pkeys(
+    src_pool: Pool,
+    dst_pool: Pool,
+    tables: list[str],
+    schema: str,
+    logger: Logger,
+) -> None:
+    """
+    Validate data for tables without primary keys by:
+    1. Getting the list of tables without primary keys
+    2. For each table, selecting 100 random rows from source
+    3. For each row, verifying it exists in destination by matching all columns
+    """
+    logger.info("Comparing tables without primary keys...")
+
+    _, no_pkeys, _ = await analyze_table_pkeys(src_pool, schema, logger)
+
+    # Filter by tables list if provided
+    if tables:
+        no_pkeys = [t for t in no_pkeys if t in tables]
+
+    if not no_pkeys:
+        logger.info("No tables without primary keys to compare.")
+        return
+
+    src_old_extra_float_digits = await src_pool.fetchval("SHOW extra_float_digits;")
+    await src_pool.execute("SET extra_float_digits TO 0;")
+
+    dst_old_extra_float_digits = await dst_pool.fetchval("SHOW extra_float_digits;")
+    await dst_pool.execute("SET extra_float_digits TO 0;")
+
+    for table in no_pkeys:
+        full_table_name = f'{schema}."{table}"'
+        logger.debug(f"Validating table without primary key: {full_table_name}...")
+
+        # Select 100 random rows from source
+        query = f"""
+        SELECT * FROM {full_table_name}
+        ORDER BY RANDOM()
+        LIMIT 100;
+        """
+
+        src_rows = await src_pool.fetch(query)
+
+        if len(src_rows) == 0:
+            logger.debug(f"Table {full_table_name} is empty in source.")
+            continue
+
+        # For each source row, check if it exists in destination
+        for src_row in src_rows:
+            # Build WHERE clause matching all columns
+            where_clauses = []
+            for key, value in src_row.items():
+                # Handle Decimal NaN values
+                if isinstance(value, Decimal) and value.is_nan():
+                    value = None
+
+                if value is None:
+                    where_clauses.append(f'"{key}" IS NULL')
+                elif isinstance(value, (int, float, Decimal)):
+                    where_clauses.append(f'"{key}" = {value}')
+                elif isinstance(value, bool):
+                    where_clauses.append(f'"{key}" = {str(value).upper()}')
+                elif isinstance(value, bytes):
+                    hex_val = value.hex()
+                    where_clauses.append(f"\"{key}\" = '\\x{hex_val}'")
+                else:
+                    # Escape single quotes in string values
+                    escaped_val = str(value).replace("'", "''")
+                    where_clauses.append(f"\"{key}\" = '{escaped_val}'")
+
+            where_clause = " AND ".join(where_clauses)
+            check_query = (
+                f"SELECT 1 FROM {full_table_name} WHERE {where_clause} LIMIT 1;"
+            )
+
+            dst_result = await dst_pool.fetch(check_query)
+
+            if len(dst_result) == 0:
+                raise AssertionError(
+                    f"Row from source not found in destination.\n"
+                    f"Table: {full_table_name}\n"
+                    f"Source Row: {dict(src_row)}"
+                )
+
+        logger.debug(f"Table {full_table_name} validated successfully.")
+
+    await src_pool.execute(f"SET extra_float_digits TO {src_old_extra_float_digits};")
+    await dst_pool.execute(f"SET extra_float_digits TO {dst_old_extra_float_digits};")
+    logger.info("Tables without primary keys validation complete!")
+
+
 async def table_empty(pool: Pool, table: str, schema: str, logger: Logger) -> bool:
     """
     return true if the table is empty
@@ -551,7 +644,7 @@ async def initialization_progress(
     if src_dataset_size["db_size"] == 0 and dst_dataset_size["db_size"] == 0:
         progress = "0 %"
     else:
-        progress = f"{str(round(int(dst_dataset_size['db_size'])/int(src_dataset_size['db_size'])*100 ,1))} %"
+        progress = f"{str(round(int(dst_dataset_size['db_size']) / int(src_dataset_size['db_size']) * 100, 1))} %"
 
     status = {
         "src_dataset_size": src_dataset_size["db_size_pretty"] or "0 bytes",

{pgbelt-0.8.3 → pgbelt-0.9.3}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "pgbelt"
-version = "0.8.3"
+version = "0.9.3"
 description = "A CLI tool used to manage Postgres data migrations from beginning to end, for a single database or a fleet, leveraging pglogical replication."
 authors = ["Varjitt Jeeva <varjitt.jeeva@autodesk.com>"]
 readme = "README.md"
@@ -10,35 +10,35 @@ packages = [
 ]
 
 [tool.poetry.dependencies]
-python = ">=3.9,<4.0"
+python = ">=3.12,<4.0"
 aiofiles = ">=0.8,<24.2"
-asyncpg = ">=0.27,<0.31"
+asyncpg = ">=0.27,<0.32"
 pydantic = ">=2.0,<3.0"
 tabulate = "^0.9.0"
-typer = ">=0.9,<0.16"
+typer = ">=0.9,<0.22"
 
 [tool.poetry.dev-dependencies]
-black = "~25.1.0"
-pre-commit = "~4.1.0"
-flake8 = "^7.1.1"
-pytest-cov = "~6.0.0"
-pytest = "^8.3.4"
-coverage = {extras = ["toml"], version = "^7.6"}
-safety = "^3.2.14"
-mypy = "^1.14"
+black = "~26.1.0"
+pre-commit = "~4.5.1"
+flake8 = "^7.3.0"
+pytest-cov = "~6.2.1"
+pytest = "^9.0.2"
+coverage = {extras = ["toml"], version = "^7.13"}
+safety = "^3.6.1"
+mypy = "^1.17"
 xdoctest = {extras = ["colors"], version = "^1.2.0"}
 flake8-bandit = "~4.1.1"
 flake8-bugbear = ">=21.9.2"
 flake8-docstrings = "^1.6.0"
-flake8-rst-docstrings = "^0.3.0"
-pep8-naming = "^0.14.1"
+flake8-rst-docstrings = "^0.4.0"
+pep8-naming = "^0.15.1"
 darglint = "^1.8.1"
-reorder-python-imports = "^3.14.0"
-pre-commit-hooks = "^5.0.0"
-Pygments = "^2.19.1"
-pyupgrade = "^3.19.1"
-pylint = "^3.3.4"
-pytest-asyncio = "~0.25.3"
+reorder-python-imports = "^3.15.0"
+pre-commit-hooks = "^6.0.0"
+Pygments = "^2.19.2"
+pyupgrade = "^3.20.0"
+pylint = "^4.0.4"
+pytest-asyncio = "~1.3.0"
 
 [build-system]
 requires = ["poetry-core>=1.0.0", "setuptools"]