From f39dd289abf18c475b38d813278cb2b6d5bf5238 Mon Sep 17 00:00:00 2001 From: rusty Date: Sat, 6 Jan 2024 20:00:57 +0400 Subject: [PATCH] Change black line length to 120 --- .../add_create_type_false.py | 6 ++-- .../add_postgres_using_to_text.py | 12 ++----- alembic_postgresql_enum/compare_dispatch.py | 9 ++--- .../detection_of_changes/enum_creation.py | 4 +-- .../detection_of_changes/enum_deletion.py | 4 +-- .../get_enum_data/declared_enums.py | 16 +++------ .../get_enum_data/defined_enums.py | 5 +-- .../operations/sync_enum_values.py | 29 ++++----------- .../sql_commands/column_default.py | 8 ++--- .../sql_commands/comparison_operators.py | 4 +-- .../sql_commands/enum_type.py | 14 ++------ pyproject.toml | 3 ++ tests/base/render_and_run.py | 8 ++--- .../get_enum_data/test_get_declared_enums.py | 12 ++----- .../test_type_decorator_enums.py | 8 ++--- tests/schemas.py | 20 +++-------- tests/sync_enum_values/test_array_column.py | 11 ++---- .../test_rename_default_if_required.py | 18 +++------- tests/sync_enum_values/test_render.py | 8 ++--- .../test_run_sync_enum_values.py | 8 ++--- tests/test_constraints/test_unique.py | 8 ++--- tests/test_enum_creation/test_add_column.py | 4 +-- .../test_enum_creation/test_create_schema.py | 12 ++----- tests/test_enum_creation/test_create_table.py | 4 +-- .../test_explicit_schema.py | 16 +++------ .../test_implicit_schema_1_4_style.py | 20 +++-------- .../test_implicit_schema_2_0_style.py | 36 +++++-------------- .../test_inherit_schema_true.py | 16 +++------ tests/utils/migration_context.py | 4 +-- 29 files changed, 83 insertions(+), 244 deletions(-) diff --git a/alembic_postgresql_enum/add_create_type_false.py b/alembic_postgresql_enum/add_create_type_false.py index 1456e25..74b6ec8 100644 --- a/alembic_postgresql_enum/add_create_type_false.py +++ b/alembic_postgresql_enum/add_create_type_false.py @@ -21,9 +21,9 @@ class ReprWorkaround(postgresql.ENUM): __module__ = "sqlalchemy.dialects.postgresql" def __repr__(self): - return f"{super().__repr__()[:-1]}, create_type=False)".replace( - "ReprWorkaround", "ENUM" - ).replace(", metadata=MetaData()", "") + return f"{super().__repr__()[:-1]}, create_type=False)".replace("ReprWorkaround", "ENUM").replace( + ", metadata=MetaData()", "" + ) def inject_repr_into_enums(column: Column): diff --git a/alembic_postgresql_enum/add_postgres_using_to_text.py b/alembic_postgresql_enum/add_postgres_using_to_text.py index 6115fde..8e3116e 100644 --- a/alembic_postgresql_enum/add_postgres_using_to_text.py +++ b/alembic_postgresql_enum/add_postgres_using_to_text.py @@ -19,9 +19,7 @@ def reverse(self): @renderers.dispatch_for(PostgresUsingAlterColumnOp) -def _postgres_using_alter_column( - autogen_context: AutogenContext, op: ops.AlterColumnOp -) -> str: +def _postgres_using_alter_column(autogen_context: AutogenContext, op: ops.AlterColumnOp) -> str: alter_column_expression = render._alter_column(autogen_context, op) postgresql_using = op.kw.get("postgresql_using", None) @@ -42,9 +40,7 @@ def _postgres_using_alter_column( def add_postgres_using_to_alter_operation(op: AlterColumnOp): op.kw["postgresql_using"] = f"{op.column_name}::{op.modify_type.name}" - log.info( - "postgresql_using added to %r.%r alteration", op.table_name, op.column_name - ) + log.info("postgresql_using added to %r.%r alteration", op.table_name, op.column_name) op.__class__ = PostgresUsingAlterColumnOp @@ -54,7 +50,5 @@ def add_postgres_using_to_text(upgrade_ops: UpgradeOps): if isinstance(group_op, ModifyTableOps): for i, op in enumerate(group_op.ops): if isinstance(op, AlterColumnOp): - if isinstance(op.existing_type, String) and column_type_is_enum( - op.modify_type - ): + if isinstance(op.existing_type, String) and column_type_is_enum(op.modify_type): add_postgres_using_to_alter_operation(op) diff --git a/alembic_postgresql_enum/compare_dispatch.py b/alembic_postgresql_enum/compare_dispatch.py index 87faf57..a61a90f 100644 --- a/alembic_postgresql_enum/compare_dispatch.py +++ b/alembic_postgresql_enum/compare_dispatch.py @@ -36,10 +36,7 @@ def compare_enums( # Issue #40 # Add schema if it is gonna be created inside the migration for operations_group in upgrade_ops.ops: - if ( - isinstance(operations_group, CreateTableOp) - and operations_group.schema not in schema_names - ): + if isinstance(operations_group, CreateTableOp) and operations_group.schema not in schema_names: schema_names.append(operations_group.schema) for schema in schema_names: @@ -48,9 +45,7 @@ def compare_enums( schema = default_schema definitions = get_defined_enums(autogen_context.connection, schema) - declarations = get_declared_enums( - autogen_context.metadata, schema, default_schema, autogen_context.connection - ) + declarations = get_declared_enums(autogen_context.metadata, schema, default_schema, autogen_context.connection) create_new_enums(definitions, declarations.enum_values, schema, upgrade_ops) diff --git a/alembic_postgresql_enum/detection_of_changes/enum_creation.py b/alembic_postgresql_enum/detection_of_changes/enum_creation.py index 42c30bc..e88cb26 100644 --- a/alembic_postgresql_enum/detection_of_changes/enum_creation.py +++ b/alembic_postgresql_enum/detection_of_changes/enum_creation.py @@ -20,6 +20,4 @@ def create_new_enums( for name, new_values in declared_enums.items(): if name not in defined_enums: log.info("Detected added enum %r with values %r", name, new_values) - upgrade_ops.ops.insert( - 0, CreateEnumOp(name=name, schema=schema, enum_values=new_values) - ) + upgrade_ops.ops.insert(0, CreateEnumOp(name=name, schema=schema, enum_values=new_values)) diff --git a/alembic_postgresql_enum/detection_of_changes/enum_deletion.py b/alembic_postgresql_enum/detection_of_changes/enum_deletion.py index 3a87d04..ae56ac6 100644 --- a/alembic_postgresql_enum/detection_of_changes/enum_deletion.py +++ b/alembic_postgresql_enum/detection_of_changes/enum_deletion.py @@ -20,6 +20,4 @@ def drop_unused_enums( for name, new_values in defined_enums.items(): if name not in declared_enums: log.info("Detected unused enum %r with values %r", name, new_values) - upgrade_ops.ops.append( - DropEnumOp(name=name, schema=schema, enum_values=new_values) - ) + upgrade_ops.ops.append(DropEnumOp(name=name, schema=schema, enum_values=new_values)) diff --git a/alembic_postgresql_enum/get_enum_data/declared_enums.py b/alembic_postgresql_enum/get_enum_data/declared_enums.py index 4e16e59..692704d 100644 --- a/alembic_postgresql_enum/get_enum_data/declared_enums.py +++ b/alembic_postgresql_enum/get_enum_data/declared_enums.py @@ -23,9 +23,7 @@ def get_enum_values(enum_type: sqlalchemy.Enum) -> "Tuple[str, ...]": dialect = postgresql.dialect def value_processor(value): - return enum_type.process_bind_param( - enum_type.impl.result_processor(dialect, enum_type)(value), dialect - ) + return enum_type.process_bind_param(enum_type.impl.result_processor(dialect, enum_type)(value), dialect) else: @@ -74,9 +72,7 @@ def get_declared_enums( } """ enum_name_to_values = dict() - enum_name_to_table_references: defaultdict[str, Set[TableReference]] = defaultdict( - set - ) + enum_name_to_table_references: defaultdict[str, Set[TableReference]] = defaultdict(set) if isinstance(metadata, list): metadata_list = metadata @@ -104,13 +100,9 @@ def get_declared_enums( if column_type.name not in enum_name_to_values: enum_name_to_values[column_type.name] = get_enum_values(column_type) - column_default = get_column_default( - connection, schema, table.name, column.name - ) + column_default = get_column_default(connection, schema, table.name, column.name) enum_name_to_table_references[column_type.name].add( - TableReference( - table.name, column.name, column_type_wrapper, column_default - ) + TableReference(table.name, column.name, column_type_wrapper, column_default) ) return DeclaredEnumValues( diff --git a/alembic_postgresql_enum/get_enum_data/defined_enums.py b/alembic_postgresql_enum/get_enum_data/defined_enums.py index ddea3ed..567b903 100644 --- a/alembic_postgresql_enum/get_enum_data/defined_enums.py +++ b/alembic_postgresql_enum/get_enum_data/defined_enums.py @@ -29,7 +29,4 @@ def get_defined_enums(connection: "Connection", schema: str) -> EnumNamesToValue "my_enum": tuple(["a", "b", "c"]), } """ - return { - _remove_schema_prefix(name, schema): tuple(values) - for name, values in get_all_enums(connection, schema) - } + return {_remove_schema_prefix(name, schema): tuple(values) for name, values in get_all_enums(connection, schema)} diff --git a/alembic_postgresql_enum/operations/sync_enum_values.py b/alembic_postgresql_enum/operations/sync_enum_values.py index 5d99760..02e0973 100644 --- a/alembic_postgresql_enum/operations/sync_enum_values.py +++ b/alembic_postgresql_enum/operations/sync_enum_values.py @@ -76,9 +76,7 @@ def _set_enum_values( rename_type(connection, schema, enum_name, temporary_enum_name) create_type(connection, schema, enum_name, new_values) - create_comparison_operators( - connection, schema, enum_name, temporary_enum_name, enum_values_to_rename - ) + create_comparison_operators(connection, schema, enum_name, temporary_enum_name, enum_values_to_rename) for table_reference in affected_columns: column_default = table_reference.existing_server_default @@ -102,9 +100,7 @@ def _set_enum_values( ) from error if column_default is not None: - column_default = rename_default_if_required( - schema, column_default, enum_name, enum_values_to_rename - ) + column_default = rename_default_if_required(schema, column_default, enum_name, enum_values_to_rename) set_default(connection, schema, table_reference, column_default) @@ -155,21 +151,13 @@ def sync_enum_values( column_type = affected_column[2] else: column_type = ColumnType.COMMON - column_default = get_column_default( - connection, schema, table_name, column_name - ) - table_references.append( - TableReference( - table_name, column_name, column_type, column_default - ) - ) + column_default = get_column_default(connection, schema, table_name, column_name) + table_references.append(TableReference(table_name, column_name, column_type, column_default)) elif isinstance(affected_column, TableReference): table_references.append(affected_column) else: - raise ValueError( - "Affected columns must contain tuples or TableReferences" - ) + raise ValueError("Affected columns must contain tuples or TableReferences") cls._set_enum_values( connection, @@ -190,12 +178,7 @@ def to_diff_tuple(self) -> Tuple[Any, ...]: @property def is_column_type_import_needed(self) -> bool: - return any( - ( - affected_column.is_column_type_import_needed - for affected_column in self.affected_columns - ) - ) + return any((affected_column.is_column_type_import_needed for affected_column in self.affected_columns)) @alembic.autogenerate.render.renderers.dispatch_for(SyncEnumValuesOp) diff --git a/alembic_postgresql_enum/sql_commands/column_default.py b/alembic_postgresql_enum/sql_commands/column_default.py index ce88e5d..889a077 100644 --- a/alembic_postgresql_enum/sql_commands/column_default.py +++ b/alembic_postgresql_enum/sql_commands/column_default.py @@ -66,12 +66,8 @@ def rename_default_if_required( column_default_value = default_value[: default_value.find("::")] for old_value, new_value in enum_values_to_rename: - column_default_value = column_default_value.replace( - f"'{old_value}'", f"'{new_value}'" - ) - column_default_value = column_default_value.replace( - f'"{old_value}"', f'"{new_value}"' - ) + column_default_value = column_default_value.replace(f"'{old_value}'", f"'{new_value}'") + column_default_value = column_default_value.replace(f'"{old_value}"', f'"{new_value}"') suffix = "[]" if is_array else "" if schema: diff --git a/alembic_postgresql_enum/sql_commands/comparison_operators.py b/alembic_postgresql_enum/sql_commands/comparison_operators.py index 292b9c6..092ef81 100644 --- a/alembic_postgresql_enum/sql_commands/comparison_operators.py +++ b/alembic_postgresql_enum/sql_commands/comparison_operators.py @@ -107,6 +107,4 @@ def drop_comparison_operators( old_enum_name: str, ): for _, comparison_function_name in OPERATORS_TO_CREATE: - _drop_comparison_operator( - connection, schema, enum_name, old_enum_name, comparison_function_name - ) + _drop_comparison_operator(connection, schema, enum_name, old_enum_name, comparison_function_name) diff --git a/alembic_postgresql_enum/sql_commands/enum_type.py b/alembic_postgresql_enum/sql_commands/enum_type.py index c5d17c1..998c133 100644 --- a/alembic_postgresql_enum/sql_commands/enum_type.py +++ b/alembic_postgresql_enum/sql_commands/enum_type.py @@ -74,19 +74,11 @@ def drop_type(connection: "Connection", schema: str, type_name: str): connection.execute(sqlalchemy.text(f"""DROP TYPE {schema}.{type_name}""")) -def rename_type( - connection: "Connection", schema: str, type_name: str, new_type_name: str -): - connection.execute( - sqlalchemy.text( - f"""ALTER TYPE {schema}.{type_name} RENAME TO {new_type_name}""" - ) - ) +def rename_type(connection: "Connection", schema: str, type_name: str, new_type_name: str): + connection.execute(sqlalchemy.text(f"""ALTER TYPE {schema}.{type_name} RENAME TO {new_type_name}""")) -def create_type( - connection: "Connection", schema: str, type_name: str, enum_values: List[str] -): +def create_type(connection: "Connection", schema: str, type_name: str, enum_values: List[str]): connection.execute( sqlalchemy.text( f"""CREATE TYPE {schema}.{type_name} AS ENUM({', '.join(f"'{value}'" for value in enum_values)})""" diff --git a/pyproject.toml b/pyproject.toml index 8ba4453..e13fd22 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -30,3 +30,6 @@ alembic = ">=1.7" [build-system] requires = ["poetry-core"] build-backend = "poetry.core.masonry.api" + +[tool.black] +line-length = 120 diff --git a/tests/base/render_and_run.py b/tests/base/render_and_run.py index 332b428..7062847 100644 --- a/tests/base/render_and_run.py +++ b/tests/base/render_and_run.py @@ -36,12 +36,8 @@ def compare_and_run( expected_upgrade = textwrap.dedent(expected_upgrade).strip("\n ") expected_downgrade = textwrap.dedent(expected_downgrade).strip("\n ") - assert ( - upgrade_code == expected_upgrade - ), f"Got:\n{upgrade_code!r}\nExpected:\n{expected_upgrade!r}" - assert ( - downgrade_code == expected_downgrade - ), f"Got:\n{downgrade_code!r}\nExpected:\n{expected_downgrade!r}" + assert upgrade_code == expected_upgrade, f"Got:\n{upgrade_code!r}\nExpected:\n{expected_upgrade!r}" + assert downgrade_code == expected_downgrade, f"Got:\n{downgrade_code!r}\nExpected:\n{expected_downgrade!r}" exec( upgrade_code, diff --git a/tests/get_enum_data/test_get_declared_enums.py b/tests/get_enum_data/test_get_declared_enums.py index 0458837..5460a25 100644 --- a/tests/get_enum_data/test_get_declared_enums.py +++ b/tests/get_enum_data/test_get_declared_enums.py @@ -19,15 +19,11 @@ def test_with_user_schema(connection: "Connection"): enum_variants = ["active", "passive"] declared_schema = get_schema_with_enum_variants(enum_variants) - function_result = get_declared_enums( - declared_schema, DEFAULT_SCHEMA, DEFAULT_SCHEMA, connection - ) + function_result = get_declared_enums(declared_schema, DEFAULT_SCHEMA, DEFAULT_SCHEMA, connection) assert function_result.enum_values == {USER_STATUS_ENUM_NAME: tuple(enum_variants)} assert function_result.enum_table_references == { - USER_STATUS_ENUM_NAME: frozenset( - (TableReference(USER_TABLE_NAME, USER_STATUS_COLUMN_NAME),) - ) + USER_STATUS_ENUM_NAME: frozenset((TableReference(USER_TABLE_NAME, USER_STATUS_COLUMN_NAME),)) } @@ -35,8 +31,6 @@ def test_with_multiple_enums(connection: "Connection"): declared_enum_values = get_declared_enum_values_with_orders_and_users() declared_schema = get_schema_by_declared_enum_values(declared_enum_values) - function_result = get_declared_enums( - declared_schema, DEFAULT_SCHEMA, DEFAULT_SCHEMA, connection - ) + function_result = get_declared_enums(declared_schema, DEFAULT_SCHEMA, DEFAULT_SCHEMA, connection) assert function_result == declared_enum_values diff --git a/tests/get_enum_data/test_type_decorator_enums.py b/tests/get_enum_data/test_type_decorator_enums.py index 37759dc..f820eaa 100644 --- a/tests/get_enum_data/test_type_decorator_enums.py +++ b/tests/get_enum_data/test_type_decorator_enums.py @@ -79,15 +79,11 @@ def get_schema_with_custom_enum() -> MetaData: def test_get_declared_enums_for_custom_enum(connection: "Connection"): declared_schema = get_schema_with_custom_enum() - function_result = get_declared_enums( - declared_schema, DEFAULT_SCHEMA, DEFAULT_SCHEMA, connection - ) + function_result = get_declared_enums(declared_schema, DEFAULT_SCHEMA, DEFAULT_SCHEMA, connection) assert function_result.enum_values == { # All declared enum variants must be taken from OrderDeliveryStatus values, see ValuesEnum - ORDER_DELIVERY_STATUS_ENUM_NAME: tuple( - enum_item.value for enum_item in OrderDeliveryStatus - ) + ORDER_DELIVERY_STATUS_ENUM_NAME: tuple(enum_item.value for enum_item in OrderDeliveryStatus) } assert function_result.enum_table_references == { ORDER_DELIVERY_STATUS_ENUM_NAME: frozenset( diff --git a/tests/schemas.py b/tests/schemas.py index 3314ecd..81e62f6 100644 --- a/tests/schemas.py +++ b/tests/schemas.py @@ -105,9 +105,7 @@ def get_declared_enum_values_with_orders_and_users() -> DeclaredEnumValues: ) ), "order_status_enum": frozenset((TableReference("orders", "order_status"),)), - "car_color_enum": frozenset( - (TableReference("cars", "colors", ColumnType.ARRAY),) - ), + "car_color_enum": frozenset((TableReference("cars", "colors", ColumnType.ARRAY),)), }, ) @@ -119,28 +117,20 @@ def _enum_column_factory( column_type: ColumnType, ) -> Column: if column_type == ColumnType.COMMON: - return Column( - column_name, postgresql.ENUM(*target.enum_values[enum_name], name=enum_name) - ) + return Column(column_name, postgresql.ENUM(*target.enum_values[enum_name], name=enum_name)) return Column( column_name, - column_type.value( - postgresql.ENUM(*target.enum_values[enum_name], name=enum_name) - ), + column_type.value(postgresql.ENUM(*target.enum_values[enum_name], name=enum_name)), ) def get_schema_by_declared_enum_values(target: DeclaredEnumValues) -> MetaData: schema = MetaData() - tables_to_columns: DefaultDict[Any, Set[Tuple[str, str, ColumnType]]] = defaultdict( - set - ) + tables_to_columns: DefaultDict[Any, Set[Tuple[str, str, ColumnType]]] = defaultdict(set) for enum_name, references in target.enum_table_references.items(): for reference in references: - tables_to_columns[reference.table_name].add( - (reference.column_name, enum_name, reference.column_type) - ) + tables_to_columns[reference.table_name].add((reference.column_name, enum_name, reference.column_type)) for table_name, columns_with_enum_names in tables_to_columns.items(): Table( diff --git a/tests/sync_enum_values/test_array_column.py b/tests/sync_enum_values/test_array_column.py index 358b72d..56c0604 100644 --- a/tests/sync_enum_values/test_array_column.py +++ b/tests/sync_enum_values/test_array_column.py @@ -39,8 +39,7 @@ def test_add_new_enum_value_render_with_array(connection: "Connection"): autogenerate._render_migration_diffs(context, template_args) assert template_args["imports"] == ( - "from alembic_postgresql_enum import ColumnType" - "\nfrom alembic_postgresql_enum import TableReference" + "from alembic_postgresql_enum import ColumnType" "\nfrom alembic_postgresql_enum import TableReference" ) assert ( @@ -125,9 +124,7 @@ def test_remove_enum_value_diff_tuple_with_array(connection: "Connection"): assert operation_name == SyncEnumValuesOp.operation_name assert old_values == old_enum_variants assert new_values == new_enum_variants - assert affected_columns == [ - TableReference(CAR_TABLE_NAME, CAR_COLORS_COLUMN_NAME, ColumnType.ARRAY) - ] + assert affected_columns == [TableReference(CAR_TABLE_NAME, CAR_COLORS_COLUMN_NAME, ColumnType.ARRAY)] def test_rename_enum_value_diff_tuple_with_array(connection: "Connection"): @@ -164,6 +161,4 @@ def test_rename_enum_value_diff_tuple_with_array(connection: "Connection"): assert operation_name == SyncEnumValuesOp.operation_name assert old_values == old_enum_variants assert new_values == new_enum_variants - assert affected_columns == [ - TableReference(CAR_TABLE_NAME, CAR_COLORS_COLUMN_NAME, ColumnType.ARRAY) - ] + assert affected_columns == [TableReference(CAR_TABLE_NAME, CAR_COLORS_COLUMN_NAME, ColumnType.ARRAY)] diff --git a/tests/sync_enum_values/test_rename_default_if_required.py b/tests/sync_enum_values/test_rename_default_if_required.py index 1a002ee..a76804e 100644 --- a/tests/sync_enum_values/test_rename_default_if_required.py +++ b/tests/sync_enum_values/test_rename_default_if_required.py @@ -6,19 +6,14 @@ def test_without_renames_with_schema(): old_default_value = "'passive'::test.order_status_old" - assert ( - rename_default_if_required("test", old_default_value, "order_status", []) - == "'passive'::test.order_status" - ) + assert rename_default_if_required("test", old_default_value, "order_status", []) == "'passive'::test.order_status" def test_with_renames_with_schema(): old_default_value = "'passive'::test.order_status_old" assert ( - rename_default_if_required( - "test", old_default_value, "order_status", [("passive", "inactive")] - ) + rename_default_if_required("test", old_default_value, "order_status", [("passive", "inactive")]) == "'inactive'::test.order_status" ) @@ -27,9 +22,7 @@ def test_array_with_renames_with_schema(): old_default_value = """'{"passive"}'::test.order_status_old""" assert ( - rename_default_if_required( - "test", old_default_value, "order_status", [("passive", "inactive")] - ) + rename_default_if_required("test", old_default_value, "order_status", [("passive", "inactive")]) == """'{"inactive"}'::test.order_status""" ) @@ -37,7 +30,4 @@ def test_array_with_renames_with_schema(): def test_array_default_value_with_schema(): old_default_value = """'{}'::test.order_status_old[]""" - assert ( - rename_default_if_required("test", old_default_value, "order_status", []) - == """'{}'::test.order_status[]""" - ) + assert rename_default_if_required("test", old_default_value, "order_status", []) == """'{}'::test.order_status[]""" diff --git a/tests/sync_enum_values/test_render.py b/tests/sync_enum_values/test_render.py index 305d952..1b48900 100644 --- a/tests/sync_enum_values/test_render.py +++ b/tests/sync_enum_values/test_render.py @@ -119,9 +119,7 @@ def test_remove_enum_value_diff_tuple(connection: "Connection"): assert operation_name == SyncEnumValuesOp.operation_name assert old_values == old_enum_variants assert new_values == new_enum_variants - assert affected_columns == [ - TableReference(USER_TABLE_NAME, USER_STATUS_COLUMN_NAME) - ] + assert affected_columns == [TableReference(USER_TABLE_NAME, USER_STATUS_COLUMN_NAME)] def test_rename_enum_value_diff_tuple(connection: "Connection"): @@ -158,6 +156,4 @@ def test_rename_enum_value_diff_tuple(connection: "Connection"): assert operation_name == SyncEnumValuesOp.operation_name assert old_values == old_enum_variants assert new_values == new_enum_variants - assert affected_columns == [ - TableReference(USER_TABLE_NAME, USER_STATUS_COLUMN_NAME) - ] + assert affected_columns == [TableReference(USER_TABLE_NAME, USER_STATUS_COLUMN_NAME)] diff --git a/tests/sync_enum_values/test_run_sync_enum_values.py b/tests/sync_enum_values/test_run_sync_enum_values.py index 1ff93c1..4c26219 100644 --- a/tests/sync_enum_values/test_run_sync_enum_values.py +++ b/tests/sync_enum_values/test_run_sync_enum_values.py @@ -114,9 +114,7 @@ def test_sync_enum_values_with_server_default(connection: "Connection"): mc = MigrationContext.configure(connection) ops = Operations(mc) - ops.sync_enum_values( - DEFAULT_SCHEMA, "order_status", new_enum_variants, (("orders", "status"),) - ) + ops.sync_enum_values(DEFAULT_SCHEMA, "order_status", new_enum_variants, (("orders", "status"),)) defined = get_defined_enums(connection, DEFAULT_SCHEMA) @@ -155,9 +153,7 @@ def test_sync_enum_values_with_server_default_renamed(connection: "Connection"): ) defined = get_defined_enums(connection, DEFAULT_SCHEMA) - order_status_default = get_column_default( - connection, DEFAULT_SCHEMA, "orders", "status" - ) + order_status_default = get_column_default(connection, DEFAULT_SCHEMA, "orders", "status") assert order_status_default == "'inactive'::order_status" assert defined == {"order_status": tuple(new_enum_variants)} diff --git a/tests/test_constraints/test_unique.py b/tests/test_constraints/test_unique.py index 1e4fa9a..f1ba889 100644 --- a/tests/test_constraints/test_unique.py +++ b/tests/test_constraints/test_unique.py @@ -17,9 +17,7 @@ def test_sync_enum_values_unique_column_with_equals(connection: "Connection"): USER_TABLE_NAME, database_schema, Column("id", Integer, primary_key=True), - Column( - "role", postgresql.ENUM(*old_enum_variants, name="user_role"), nullable=True - ), + Column("role", postgresql.ENUM(*old_enum_variants, name="user_role"), nullable=True), Index( "admin_unique", "role", @@ -62,9 +60,7 @@ def test_sync_enum_values_unique_column_with_not_equals(connection: "Connection" USER_TABLE_NAME, database_schema, Column("id", Integer, primary_key=True), - Column( - "role", postgresql.ENUM(*old_enum_variants, name="user_role"), nullable=True - ), + Column("role", postgresql.ENUM(*old_enum_variants, name="user_role"), nullable=True), Index( "admin_unique", "role", diff --git a/tests/test_enum_creation/test_add_column.py b/tests/test_enum_creation/test_add_column.py index dcb60f2..393fa6d 100644 --- a/tests/test_enum_creation/test_add_column.py +++ b/tests/test_enum_creation/test_add_column.py @@ -125,9 +125,7 @@ def test_with_non_native_enum(connection: "Connection"): Column("id", Integer, primary_key=True), Column( USER_STATUS_COLUMN_NAME, - sqlalchemy.Enum( - *new_enum_variants, name=USER_STATUS_ENUM_NAME, native_enum=False - ), + sqlalchemy.Enum(*new_enum_variants, name=USER_STATUS_ENUM_NAME, native_enum=False), ), ) diff --git a/tests/test_enum_creation/test_create_schema.py b/tests/test_enum_creation/test_create_schema.py index 8144340..0261e5f 100644 --- a/tests/test_enum_creation/test_create_schema.py +++ b/tests/test_enum_creation/test_create_schema.py @@ -29,9 +29,7 @@ def test_create_enum_on_create_table_inside_new_schema(connection: "Connection") Column("id", Integer, primary_key=True), Column( USER_STATUS_COLUMN_NAME, - postgresql.ENUM( - *new_enum_variants, name=USER_STATUS_ENUM_NAME, metadata=target_schema - ), + postgresql.ENUM(*new_enum_variants, name=USER_STATUS_ENUM_NAME, metadata=target_schema), ), ) @@ -65,9 +63,5 @@ def test_create_enum_on_create_table_inside_new_schema(connection: "Connection") expected_upgrade = textwrap.dedent(expected_upgrade).strip("\n ") expected_downgrade = textwrap.dedent(expected_downgrade).strip("\n ") - assert ( - upgrade_code == expected_upgrade - ), f"Got:\n{upgrade_code!r}\nExpected:\n{expected_upgrade!r}" - assert ( - downgrade_code == expected_downgrade - ), f"Got:\n{downgrade_code!r}\nExpected:\n{expected_downgrade!r}" + assert upgrade_code == expected_upgrade, f"Got:\n{upgrade_code!r}\nExpected:\n{expected_upgrade!r}" + assert downgrade_code == expected_downgrade, f"Got:\n{downgrade_code!r}\nExpected:\n{expected_downgrade!r}" diff --git a/tests/test_enum_creation/test_create_table.py b/tests/test_enum_creation/test_create_table.py index c1f0fae..b154648 100644 --- a/tests/test_enum_creation/test_create_table.py +++ b/tests/test_enum_creation/test_create_table.py @@ -175,9 +175,7 @@ def test_create_enum_on_create_table_with_another_schema_on_metadata( Column("id", Integer, primary_key=True), Column( USER_STATUS_COLUMN_NAME, - postgresql.ENUM( - *new_enum_variants, name=USER_STATUS_ENUM_NAME, metadata=target_schema - ), + postgresql.ENUM(*new_enum_variants, name=USER_STATUS_ENUM_NAME, metadata=target_schema), ), ) diff --git a/tests/test_without_schema_changes/test_explicit_schema.py b/tests/test_without_schema_changes/test_explicit_schema.py index 1231419..0db04a1 100644 --- a/tests/test_without_schema_changes/test_explicit_schema.py +++ b/tests/test_without_schema_changes/test_explicit_schema.py @@ -46,25 +46,17 @@ def test_get_defined_enums(connection: "Connection"): function_result = get_defined_enums(connection, ANOTHER_SCHEMA_NAME) - assert function_result == { - "test_status": tuple(map(lambda item: item.value, _TestStatus)) - } + assert function_result == {"test_status": tuple(map(lambda item: item.value, _TestStatus))} def test_get_declared_enums(connection: "Connection"): declared_schema = my_metadata - function_result = get_declared_enums( - declared_schema, ANOTHER_SCHEMA_NAME, DEFAULT_SCHEMA, connection - ) + function_result = get_declared_enums(declared_schema, ANOTHER_SCHEMA_NAME, DEFAULT_SCHEMA, connection) - assert function_result.enum_values == { - "test_status": tuple(map(lambda item: item.value, _TestStatus)) - } + assert function_result.enum_values == {"test_status": tuple(map(lambda item: item.value, _TestStatus))} assert function_result.enum_table_references == { - "test_status": frozenset( - [TableReference(TableWithExplicitEnumSchema.__tablename__, "status")] - ) + "test_status": frozenset([TableReference(TableWithExplicitEnumSchema.__tablename__, "status")]) } diff --git a/tests/test_without_schema_changes/test_implicit_schema_1_4_style.py b/tests/test_without_schema_changes/test_implicit_schema_1_4_style.py index f7e9af5..e15fe60 100644 --- a/tests/test_without_schema_changes/test_implicit_schema_1_4_style.py +++ b/tests/test_without_schema_changes/test_implicit_schema_1_4_style.py @@ -51,34 +51,24 @@ def test_get_defined_enums_metadata(connection: "Connection"): # Check that enum is created inside `public` schema function_result = get_defined_enums(connection, DEFAULT_SCHEMA) - assert function_result == { - "test_status": tuple(map(lambda item: item.value, _TestStatus)) - } + assert function_result == {"test_status": tuple(map(lambda item: item.value, _TestStatus))} def test_get_declared_enums(connection: "Connection"): declared_schema = my_metadata # Check that enum is not created inside `another` schema - function_result = get_declared_enums( - declared_schema, ANOTHER_SCHEMA_NAME, DEFAULT_SCHEMA, connection - ) + function_result = get_declared_enums(declared_schema, ANOTHER_SCHEMA_NAME, DEFAULT_SCHEMA, connection) assert function_result.enum_values == {} assert function_result.enum_table_references == {} # Check that enum is created inside `public` schema - function_result = get_declared_enums( - declared_schema, DEFAULT_SCHEMA, DEFAULT_SCHEMA, connection - ) + function_result = get_declared_enums(declared_schema, DEFAULT_SCHEMA, DEFAULT_SCHEMA, connection) - assert function_result.enum_values == { - "test_status": tuple(map(lambda item: item.value, _TestStatus)) - } + assert function_result.enum_values == {"test_status": tuple(map(lambda item: item.value, _TestStatus))} assert function_result.enum_table_references == { - "test_status": frozenset( - [TableReference(TableWithExplicitEnumSchema.__tablename__, "status")] - ) + "test_status": frozenset([TableReference(TableWithExplicitEnumSchema.__tablename__, "status")]) } diff --git a/tests/test_without_schema_changes/test_implicit_schema_2_0_style.py b/tests/test_without_schema_changes/test_implicit_schema_2_0_style.py index 0c06607..4b61e3f 100644 --- a/tests/test_without_schema_changes/test_implicit_schema_2_0_style.py +++ b/tests/test_without_schema_changes/test_implicit_schema_2_0_style.py @@ -47,9 +47,7 @@ class TableWithExplicitEnumSchema(Base): return my_metadata -@pytest.mark.skipif( - sqlalchemy.__version__.startswith("1."), reason="Table are made in 2.0 style" -) +@pytest.mark.skipif(sqlalchemy.__version__.startswith("1."), reason="Table are made in 2.0 style") def test_get_defined_enums_metadata(connection: "Connection"): my_metadata = get_my_metadata() database_schema = my_metadata @@ -57,42 +55,28 @@ def test_get_defined_enums_metadata(connection: "Connection"): function_result = get_defined_enums(connection, "public") - assert function_result == { - "test_status": tuple(map(lambda item: item.value, _TestStatus)) - } + assert function_result == {"test_status": tuple(map(lambda item: item.value, _TestStatus))} -@pytest.mark.skipif( - sqlalchemy.__version__.startswith("1."), reason="Table are made in 2.0 style" -) +@pytest.mark.skipif(sqlalchemy.__version__.startswith("1."), reason="Table are made in 2.0 style") def test_get_declared_enums(connection: "Connection"): my_metadata = get_my_metadata() declared_schema = my_metadata # Check that enum is not created inside `another` schema - function_result = get_declared_enums( - declared_schema, ANOTHER_SCHEMA_NAME, DEFAULT_SCHEMA, connection - ) + function_result = get_declared_enums(declared_schema, ANOTHER_SCHEMA_NAME, DEFAULT_SCHEMA, connection) assert function_result.enum_values == {} assert function_result.enum_table_references == {} # Check that enum is created inside `public` schema - function_result = get_declared_enums( - declared_schema, DEFAULT_SCHEMA, DEFAULT_SCHEMA, connection - ) + function_result = get_declared_enums(declared_schema, DEFAULT_SCHEMA, DEFAULT_SCHEMA, connection) - assert function_result.enum_values == { - "test_status": tuple(map(lambda item: item.value, _TestStatus)) - } - assert function_result.enum_table_references == { - "test_status": frozenset([TableReference("test", "status")]) - } + assert function_result.enum_values == {"test_status": tuple(map(lambda item: item.value, _TestStatus))} + assert function_result.enum_table_references == {"test_status": frozenset([TableReference("test", "status")])} -@pytest.mark.skipif( - sqlalchemy.__version__.startswith("1."), reason="Table are made in 2.0 style" -) +@pytest.mark.skipif(sqlalchemy.__version__.startswith("1."), reason="Table are made in 2.0 style") def test_compare_and_run_create_table(connection: "Connection"): my_metadata = get_my_metadata() target_schema = my_metadata @@ -120,9 +104,7 @@ def test_compare_and_run_create_table(connection: "Connection"): ) -@pytest.mark.skipif( - sqlalchemy.__version__.startswith("1."), reason="Table are made in 2.0 style" -) +@pytest.mark.skipif(sqlalchemy.__version__.startswith("1."), reason="Table are made in 2.0 style") def test_compare_and_run(connection: "Connection"): my_metadata = get_my_metadata() database_schema = my_metadata diff --git a/tests/test_without_schema_changes/test_inherit_schema_true.py b/tests/test_without_schema_changes/test_inherit_schema_true.py index 8e2cbf5..0b181bc 100644 --- a/tests/test_without_schema_changes/test_inherit_schema_true.py +++ b/tests/test_without_schema_changes/test_inherit_schema_true.py @@ -46,25 +46,17 @@ def test_get_defined_enums(connection: "Connection"): function_result = get_defined_enums(connection, ANOTHER_SCHEMA_NAME) - assert function_result == { - "test_status": tuple(map(lambda item: item.value, _TestStatus)) - } + assert function_result == {"test_status": tuple(map(lambda item: item.value, _TestStatus))} def test_get_declared_enums(connection: "Connection"): declared_schema = my_metadata - function_result = get_declared_enums( - declared_schema, ANOTHER_SCHEMA_NAME, DEFAULT_SCHEMA, connection - ) + function_result = get_declared_enums(declared_schema, ANOTHER_SCHEMA_NAME, DEFAULT_SCHEMA, connection) - assert function_result.enum_values == { - "test_status": tuple(map(lambda item: item.value, _TestStatus)) - } + assert function_result.enum_values == {"test_status": tuple(map(lambda item: item.value, _TestStatus))} assert function_result.enum_table_references == { - "test_status": frozenset( - [TableReference(TableWithExplicitEnumSchema.__tablename__, "status")] - ) + "test_status": frozenset([TableReference(TableWithExplicitEnumSchema.__tablename__, "status")]) } diff --git a/tests/utils/migration_context.py b/tests/utils/migration_context.py index 8e29ad3..b8fd08b 100644 --- a/tests/utils/migration_context.py +++ b/tests/utils/migration_context.py @@ -22,9 +22,7 @@ def default_migration_options(target_schema: Union[MetaData, List[MetaData]]) -> } -def create_migration_context( - connection: "Connection", target_schema: Union[MetaData, List[MetaData]] -): +def create_migration_context(connection: "Connection", target_schema: Union[MetaData, List[MetaData]]): return MigrationContext.configure( connection=connection, opts=default_migration_options(target_schema),