pgbelt 0.8.2__py3-none-any.whl → 0.9.2__py3-none-any.whl

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/util/dump.py

@@ -76,6 +76,33 @@ 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 adding transaction_timeout lines.
+    keywords = ["transaction_timeout"]
+    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 +115,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 +150,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 +217,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 +318,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/util/logs.py

@@ -1,4 +1,5 @@
 import logging
+from datetime import datetime
 from os import getenv
 from os import makedirs
 
@@ -8,7 +9,7 @@ FORMATTER = "{asctime} {name}:{levelname} {message}"
 # if this module is ever imported we set up the root logger to log to stderr
 root_level = int(getenv("LOG_LEVEL", logging.DEBUG))
 root_handler = logging.StreamHandler()
-formatter = logging.Formatter(fmt=FORMATTER, datefmt='%Y-%m-%d %H:%M:%S', style='{')
+formatter = logging.Formatter(fmt=FORMATTER, datefmt="%Y-%m-%d %H:%M:%S", style="{")
 root_handler.setFormatter(formatter)
 root_handler.setLevel(root_level)
 root_logger = logging.getLogger("dbup")
@@ -20,13 +21,21 @@ def log_file_dir(db: str, dc: str) -> str:
     return f"logs/{db}/{dc}"
 
 
-def log_file_path(db: str, dc: str) -> str:
-    return f"logs/{db}/{dc}/logs.txt"
+def log_file_path(db: str, dc: str, kind: str) -> str:
+    timestamp = datetime.now().strftime("%Y-%m-%d-%H-%M-%S")
+    if kind:
+        return f"logs/{db}/{dc}/{timestamp}-{kind}.txt"
+    else:
+        return f"logs/{db}/{dc}/{timestamp}.txt"
 
 
 def get_logger(db: str, dc: str, kind: str = "") -> logging.Logger:
     # When we set up a logger for that db that emits to a file
-    logger = logging.getLogger(f"dbup.{db}.{dc}")
+    logger = (
+        logging.getLogger(f"dbup.{db}.{dc}.{kind}")
+        if kind
+        else logging.getLogger(f"dbup.{db}.{dc}")
+    )
     if not logger.handlers:
         skip_file_handler = False
 
@@ -41,8 +50,10 @@ def get_logger(db: str, dc: str, kind: str = "") -> logging.Logger:
             pass
 
         if not skip_file_handler:
-            handler = logging.FileHandler(log_file_path(db, dc), mode="w")
-            handler.setFormatter(logging.Formatter(FORMATTER, datefmt='%Y-%m-%d %H:%M:%S', style="{"))
+            handler = logging.FileHandler(log_file_path(db, dc, kind), mode="w")
+            handler.setFormatter(
+                logging.Formatter(FORMATTER, datefmt="%Y-%m-%d %H:%M:%S", style="{")
+            )
             # always log everything to the file
             logger.setLevel(logging.DEBUG)
             logger.addHandler(handler)

pgbelt/util/postgres.py

@@ -551,7 +551,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.2.dist-info → pgbelt-0.9.2.dist-info}/METADATA

@@ -1,21 +1,20 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: pgbelt
-Version: 0.8.2
+Version: 0.9.2
 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.2.dist-info → pgbelt-0.9.2.dist-info}/RECORD

@@ -3,7 +3,7 @@ pgbelt/cmd/__init__.py,sha256=28SxbIChyvJ1mLoI8XJQPrPPwKA6852V9jtnFm8R0Nw,462
 pgbelt/cmd/convenience.py,sha256=RY762BYoyOccmhHqSOaHWIPVBzY4kU0qZautTprGps0,5857
 pgbelt/cmd/helpers.py,sha256=anMAkZjJRy7n0EwewyMNJGJ4Jx9keSNZdzWqi3ICNgI,5292
 pgbelt/cmd/login.py,sha256=FNg7shEIC2iwiDjOMza2ZvBv_33U1GMKRh51vsGMTb8,3351
-pgbelt/cmd/preflight.py,sha256=-78Puqqf1rCxNQEyn4bQIAORez_tsy6zJAbSuO_de9s,20676
+pgbelt/cmd/preflight.py,sha256=GH2IE-yb1HvbpwSwm-jJG1dnRO9CXfSsTH5OqYEVyv4,21557
 pgbelt/cmd/schema.py,sha256=OuxJdUILxlNCvaBV71Si8035pX3LVwHm5Urt0vftO8E,4389
 pgbelt/cmd/setup.py,sha256=Jp5sqT9_whoVBiOzAlOzX1ubtXQADYBkBrJldch_fKk,6627
 pgbelt/cmd/status.py,sha256=8K1c2OMZ3uHNmEh-5a2a0fhTDmCU0RohzgjjVfXoKGo,5385
@@ -16,12 +16,12 @@ pgbelt/config/remote.py,sha256=D9bOekVfMU1xX2Wy0OiJwSXetxJUdt9Tn5Fukwn9rnE,5307
 pgbelt/main.py,sha256=YiagBiGt8pbNlukkRxROXnQX1Tx6ax7c6riuHRCrPYU,186
 pgbelt/util/__init__.py,sha256=-6KkvVMz-yGNQfeoo4CZZrgWKXYmFd4CMyoiao8OnFE,40
 pgbelt/util/asyncfuncs.py,sha256=7i_GpBmUNNZ8RUGvU-q5nclsoaCm6Lx8jLP8usYvmZc,583
-pgbelt/util/dump.py,sha256=R5eI1MFwbv5M6ICnkmjhugj3ZhpWu5sjT20ixEXNfC4,14218
-pgbelt/util/logs.py,sha256=E6doEhi8vrusmYUTZRdjKHP-h2dDiExCjgEtMl7epPw,1793
+pgbelt/util/dump.py,sha256=W814ULJPM9IBEhmvMFRD2E8DkqTuXZRuRtLXT8k4xhU,14691
+pgbelt/util/logs.py,sha256=3Kk_dERXLsTwLxFS6tzI8fE0sRi5QrBYHJc4Al6ZCMA,2110
 pgbelt/util/pglogical.py,sha256=Y6KZBeiH85zhNSvhATqh0xozhfUMyQnPWN1HwRosZFo,13613
-pgbelt/util/postgres.py,sha256=0Jx0auJZsSigDX57M1J9ntN1booL1AUxPc8oBYzsbUE,20076
-pgbelt-0.8.2.dist-info/LICENSE,sha256=FQ5cFkW02dKK3LmKH8z-rwn93tWSCh7lsxfNUiWcFsg,10758
-pgbelt-0.8.2.dist-info/METADATA,sha256=dhrSqkEUjn642o_hu0sZn8zUhCQLAMDZmUZSqrBmY4s,3011
-pgbelt-0.8.2.dist-info/WHEEL,sha256=Nq82e9rUAnEjt98J6MlVmMCZb-t9cYE2Ir1kpBmnWfs,88
-pgbelt-0.8.2.dist-info/entry_points.txt,sha256=SCz_poPjkaVnWpJ-CeytAnDzbVc6l0WalOwitIqW_3g,40
-pgbelt-0.8.2.dist-info/RECORD,,
+pgbelt/util/postgres.py,sha256=ftBontoWkU7XaDXaBnsSJYYx7s2Su0xkcTyVCzwKJm0,20080
+pgbelt-0.9.2.dist-info/METADATA,sha256=we33iVu7QH6GjgfHHqzL9ISEfq73y2S8gf5wySkPHHQ,2933
+pgbelt-0.9.2.dist-info/WHEEL,sha256=kJCRJT_g0adfAJzTx2GUMmS80rTJIVHRCfG0DQgLq3o,88
+pgbelt-0.9.2.dist-info/entry_points.txt,sha256=SCz_poPjkaVnWpJ-CeytAnDzbVc6l0WalOwitIqW_3g,40
+pgbelt-0.9.2.dist-info/licenses/LICENSE,sha256=FQ5cFkW02dKK3LmKH8z-rwn93tWSCh7lsxfNUiWcFsg,10758
+pgbelt-0.9.2.dist-info/RECORD,,

{pgbelt-0.8.2.dist-info → pgbelt-0.9.2.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: poetry-core 1.9.1
+Generator: poetry-core 2.3.1
 Root-Is-Purelib: true
 Tag: py3-none-any