add flake8 config

Author: aminalaee

.flake8

@@ -0,0 +1,5 @@
+[flake8]
+ignore = E203, E266, E501, W503, F403, F401
+max-line-length = 79
+max-complexity = 18
+select = B,C,E,F,W,T4,B9

piccolo/apps/asgi/commands/new.py

@@ -18,7 +18,9 @@ def print_instruction(message: str):
 
 
 def get_options_string(options: t.List[str]):
-    return ", ".join([f"{name} [{index}]" for index, name in enumerate(options)])
+    return ", ".join(
+        [f"{name} [{index}]" for index, name in enumerate(options)]
+    )
 
 
 def get_routing_framework() -> str:
@@ -98,11 +100,15 @@ def new(root: str = ".", name: str = "piccolo_project"):
                         print(f"Problem processing {output_file_name}")
                         raise exception
 
-                with open(os.path.join(output_dir_path, output_file_name), "w") as f:
+                with open(
+                    os.path.join(output_dir_path, output_file_name), "w"
+                ) as f:
                     f.write(output_contents)
             else:
                 if file_name.endswith(".jinja_raw"):
-                    output_file_name = file_name.replace(".jinja_raw", ".jinja")
+                    output_file_name = file_name.replace(
+                        ".jinja_raw", ".jinja"
+                    )
                 else:
                     output_file_name = file_name
 
@@ -112,5 +118,6 @@ def new(root: str = ".", name: str = "piccolo_project"):
                 )
 
     print(
-        "Run `pip install -r requirements.txt` and `python main.py` to get " "started."
+        "Run `pip install -r requirements.txt` and `python main.py` to get "
+        "started."
     )

piccolo/apps/migrations/auto/diffable_table.py

@@ -3,7 +3,11 @@
 import typing as t
 from dataclasses import dataclass, field
 
-from piccolo.apps.migrations.auto.operations import AddColumn, AlterColumn, DropColumn
+from piccolo.apps.migrations.auto.operations import (
+    AddColumn,
+    AlterColumn,
+    DropColumn,
+)
 from piccolo.apps.migrations.auto.serialisation import (
     deserialise_params,
     serialise_params,
@@ -65,14 +69,20 @@ class DiffableTable:
     previous_class_name: t.Optional[str] = None
 
     def __post_init__(self):
-        self.columns_map: t.Dict[str, Column] = {i._meta.name: i for i in self.columns}
+        self.columns_map: t.Dict[str, Column] = {
+            i._meta.name: i for i in self.columns
+        }
 
     def __sub__(self, value: DiffableTable) -> TableDelta:
         if not isinstance(value, DiffableTable):
-            raise ValueError("Can only diff with other DiffableTable instances")
+            raise ValueError(
+                "Can only diff with other DiffableTable instances"
+            )
 
         if value.class_name != self.class_name:
-            raise ValueError("The two tables don't appear to have the same name.")
+            raise ValueError(
+                "The two tables don't appear to have the same name."
+            )
 
         add_columns = [
             AddColumn(
@@ -114,7 +124,8 @@ def __sub__(self, value: DiffableTable) -> TableDelta:
             )
 
             old_params = {
-                key: existing_column._meta.params.get(key) for key, _ in delta.items()
+                key: existing_column._meta.params.get(key)
+                for key, _ in delta.items()
             }
 
             if delta or (column.__class__ != existing_column.__class__):
@@ -162,7 +173,9 @@ def to_table_class(self) -> t.Type[Table]:
         _Table: t.Type[Table] = create_table_class(
             class_name=self.class_name,
             class_kwargs={"tablename": self.tablename},
-            class_members={column._meta.name: column for column in self.columns},
+            class_members={
+                column._meta.name: column for column in self.columns
+            },
         )
 
         return _Table

piccolo/apps/migrations/auto/migration_manager.py

@@ -31,12 +31,22 @@ class AddColumnCollection:
     def append(self, add_column: AddColumnClass):
         self.add_columns.append(add_column)
 
-    def for_table_class_name(self, table_class_name: str) -> t.List[AddColumnClass]:
-        return [i for i in self.add_columns if i.table_class_name == table_class_name]
+    def for_table_class_name(
+        self, table_class_name: str
+    ) -> t.List[AddColumnClass]:
+        return [
+            i
+            for i in self.add_columns
+            if i.table_class_name == table_class_name
+        ]
 
-    def columns_for_table_class_name(self, table_class_name: str) -> t.List[Column]:
+    def columns_for_table_class_name(
+        self, table_class_name: str
+    ) -> t.List[Column]:
         return [
-            i.column for i in self.add_columns if i.table_class_name == table_class_name
+            i.column
+            for i in self.add_columns
+            if i.table_class_name == table_class_name
         ]
 
     @property
@@ -51,8 +61,14 @@ class DropColumnCollection:
     def append(self, drop_column: DropColumn):
         self.drop_columns.append(drop_column)
 
-    def for_table_class_name(self, table_class_name: str) -> t.List[DropColumn]:
-        return [i for i in self.drop_columns if i.table_class_name == table_class_name]
+    def for_table_class_name(
+        self, table_class_name: str
+    ) -> t.List[DropColumn]:
+        return [
+            i
+            for i in self.drop_columns
+            if i.table_class_name == table_class_name
+        ]
 
     @property
     def table_class_names(self) -> t.List[str]:
@@ -66,9 +82,13 @@ class RenameColumnCollection:
     def append(self, rename_column: RenameColumn):
         self.rename_columns.append(rename_column)
 
-    def for_table_class_name(self, table_class_name: str) -> t.List[RenameColumn]:
+    def for_table_class_name(
+        self, table_class_name: str
+    ) -> t.List[RenameColumn]:
         return [
-            i for i in self.rename_columns if i.table_class_name == table_class_name
+            i
+            for i in self.rename_columns
+            if i.table_class_name == table_class_name
         ]
 
     @property
@@ -83,8 +103,14 @@ class AlterColumnCollection:
     def append(self, alter_column: AlterColumn):
         self.alter_columns.append(alter_column)
 
-    def for_table_class_name(self, table_class_name: str) -> t.List[AlterColumn]:
-        return [i for i in self.alter_columns if i.table_class_name == table_class_name]
+    def for_table_class_name(
+        self, table_class_name: str
+    ) -> t.List[AlterColumn]:
+        return [
+            i
+            for i in self.alter_columns
+            if i.table_class_name == table_class_name
+        ]
 
     @property
     def table_class_names(self) -> t.List[str]:
@@ -103,12 +129,18 @@ class MigrationManager:
     add_tables: t.List[DiffableTable] = field(default_factory=list)
     drop_tables: t.List[DiffableTable] = field(default_factory=list)
     rename_tables: t.List[RenameTable] = field(default_factory=list)
-    add_columns: AddColumnCollection = field(default_factory=AddColumnCollection)
-    drop_columns: DropColumnCollection = field(default_factory=DropColumnCollection)
+    add_columns: AddColumnCollection = field(
+        default_factory=AddColumnCollection
+    )
+    drop_columns: DropColumnCollection = field(
+        default_factory=DropColumnCollection
+    )
     rename_columns: RenameColumnCollection = field(
         default_factory=RenameColumnCollection
     )
-    alter_columns: AlterColumnCollection = field(default_factory=AlterColumnCollection)
+    alter_columns: AlterColumnCollection = field(
+        default_factory=AlterColumnCollection
+    )
     raw: t.List[t.Union[t.Callable, t.Coroutine]] = field(default_factory=list)
     raw_backwards: t.List[t.Union[t.Callable, t.Coroutine]] = field(
         default_factory=list
@@ -124,7 +156,9 @@ def add_table(
             columns = []
 
         self.add_tables.append(
-            DiffableTable(class_name=class_name, tablename=tablename, columns=columns)
+            DiffableTable(
+                class_name=class_name, tablename=tablename, columns=columns
+            )
         )
 
     def drop_table(self, class_name: str, tablename: str):
@@ -185,7 +219,9 @@ def add_column(
             )
         )
 
-    def drop_column(self, table_class_name: str, tablename: str, column_name: str):
+    def drop_column(
+        self, table_class_name: str, tablename: str, column_name: str
+    ):
         self.drop_columns.append(
             DropColumn(
                 table_class_name=table_class_name,
@@ -287,7 +323,9 @@ async def get_table_from_snaphot(
 
     async def _run_alter_columns(self, backwards=False):
         for table_class_name in self.alter_columns.table_class_names:
-            alter_columns = self.alter_columns.for_table_class_name(table_class_name)
+            alter_columns = self.alter_columns.for_table_class_name(
+                table_class_name
+            )
 
             if not alter_columns:
                 continue
@@ -299,10 +337,16 @@ async def _run_alter_columns(self, backwards=False):
 
             for alter_column in alter_columns:
 
-                params = alter_column.old_params if backwards else alter_column.params
+                params = (
+                    alter_column.old_params
+                    if backwards
+                    else alter_column.params
+                )
 
                 old_params = (
-                    alter_column.params if backwards else alter_column.old_params
+                    alter_column.params
+                    if backwards
+                    else alter_column.old_params
                 )
 
                 ###############################################################
@@ -319,7 +363,9 @@ async def _run_alter_columns(self, backwards=False):
                     else alter_column.old_column_class
                 )
 
-                if (old_column_class is not None) and (column_class is not None):
+                if (old_column_class is not None) and (
+                    column_class is not None
+                ):
                     if old_column_class != column_class:
                         old_column = old_column_class(**old_params)
                         old_column._meta._table = _Table
@@ -356,7 +402,9 @@ async def _run_alter_columns(self, backwards=False):
                     column = Column()
                     column._meta._table = _Table
                     column._meta._name = column_name
-                    await _Table.alter().set_unique(column=column, boolean=unique).run()
+                    await _Table.alter().set_unique(
+                        column=column, boolean=unique
+                    ).run()
 
                 index = params.get("index")
                 index_method = params.get("index_method")
@@ -379,7 +427,9 @@ async def _run_alter_columns(self, backwards=False):
                     column._meta._table = _Table
                     column._meta._name = column_name
                     if index is True:
-                        kwargs = {"method": index_method} if index_method else {}
+                        kwargs = (
+                            {"method": index_method} if index_method else {}
+                        )
                         await _Table.create_index(
                             [column], if_not_exists=True, **kwargs
                         ).run()
@@ -419,7 +469,9 @@ async def _run_drop_tables(self, backwards=False):
                 await _Table.create_table().run()
         else:
             for diffable_table in self.drop_tables:
-                await (diffable_table.to_table_class().alter().drop_table().run())
+                await (
+                    diffable_table.to_table_class().alter().drop_table().run()
+                )
 
     async def _run_drop_columns(self, backwards=False):
         if backwards:
@@ -437,7 +489,9 @@ async def _run_drop_columns(self, backwards=False):
                 ).run()
         else:
             for table_class_name in self.drop_columns.table_class_names:
-                columns = self.drop_columns.for_table_class_name(table_class_name)
+                columns = self.drop_columns.for_table_class_name(
+                    table_class_name
+                )
 
                 if not columns:
                     continue
@@ -448,7 +502,9 @@ async def _run_drop_columns(self, backwards=False):
                 )
 
                 for column in columns:
-                    await _Table.alter().drop_column(column=column.column_name).run()
+                    await _Table.alter().drop_column(
+                        column=column.column_name
+                    ).run()
 
     async def _run_rename_tables(self, backwards=False):
         for rename_table in self.rename_tables:
@@ -458,10 +514,14 @@ async def _run_rename_tables(self, backwards=False):
                 else rename_table.old_class_name
             )
             tablename = (
-                rename_table.new_tablename if backwards else rename_table.old_tablename
+                rename_table.new_tablename
+                if backwards
+                else rename_table.old_tablename
             )
             new_tablename = (
-                rename_table.old_tablename if backwards else rename_table.new_tablename
+                rename_table.old_tablename
+                if backwards
+                else rename_table.new_tablename
             )
 
             _Table: t.Type[Table] = create_table_class(
@@ -472,7 +532,9 @@ async def _run_rename_tables(self, backwards=False):
 
     async def _run_rename_columns(self, backwards=False):
         for table_class_name in self.rename_columns.table_class_names:
-            columns = self.rename_columns.for_table_class_name(table_class_name)
+            columns = self.rename_columns.for_table_class_name(
+                table_class_name
+            )
 
             if not columns:
                 continue
@@ -502,14 +564,17 @@ async def _run_rename_columns(self, backwards=False):
     async def _run_add_tables(self, backwards=False):
         if backwards:
             for add_table in self.add_tables:
-                await add_table.to_table_class().alter().drop_table(cascade=True).run()
+                await add_table.to_table_class().alter().drop_table(
+                    cascade=True
+                ).run()
         else:
             for add_table in self.add_tables:
                 _Table: t.Type[Table] = create_table_class(
                     class_name=add_table.class_name,
                     class_kwargs={"tablename": add_table.tablename},
                     class_members={
-                        column._meta.name: column for column in add_table.columns
+                        column._meta.name: column
+                        for column in add_table.columns
                     },
                 )