black formatted

src/masoniteorm/commands/MigrateStatusCommand.py

@@ -30,12 +30,20 @@ def handle(self):
             batch = migration_data["batch"]
 
             migrations.append(
-                ["<info>Y</info>", f"<comment>{migration_file}</comment>", f"<info>{batch}</info>"]
+                [
+                    "<info>Y</info>",
+                    f"<comment>{migration_file}</comment>",
+                    f"<info>{batch}</info>",
+                ]
             )
 
         for migration_file in migration.get_unran_migrations():
             migrations.append(
-                ["<error>N</error>", f"<comment>{migration_file}</comment>", "<info>-</info>"]
+                [
+                    "<error>N</error>",
+                    f"<comment>{migration_file}</comment>",
+                    "<info>-</info>",
+                ]
             )
 
         table.set_rows(migrations)

src/masoniteorm/query/QueryBuilder.py

@@ -9,7 +9,8 @@
     HTTP404,
     ConnectionNotRegistered,
     ModelNotFound,
-    MultipleRecordsFound, InvalidArgument,
+    MultipleRecordsFound,
+    InvalidArgument,
 )
 from ..expressions.expressions import (
     AggregateExpression,
@@ -47,7 +48,7 @@ def __init__(
         scopes=None,
         schema=None,
         dry=False,
-        config_path=None
+        config_path=None,
     ):
         """QueryBuilder initializer
 

src/masoniteorm/schema/Schema.py

@@ -57,7 +57,7 @@ def __init__(
         grammar=None,
         connection_details=None,
         schema=None,
-        config_path=None
+        config_path=None,
     ):
         self._dry = dry
         self.connection = connection
@@ -306,11 +306,7 @@ def get_all_tables(self):
 
         result = self.new_connection().query(sql, ())
 
-        return (
-            list(map(lambda t: list(t.values())[0], result))
-            if result
-            else []
-        )
+        return list(map(lambda t: list(t.values())[0], result)) if result else []
 
     def has_table(self, table, query_only=False):
         """Checks if the a database has a specific table

tests/models/test_models.py

@@ -19,30 +19,17 @@ class ModelTest(Model):
 
 
 class FillableModelTest(Model):
-    __fillable__ = [
-        "due_date",
-        "is_vip",
-    ]
+    __fillable__ = ["due_date", "is_vip"]
 
 
 class InvalidFillableGuardedModelTest(Model):
-    __fillable__ = [
-        "due_date",
-    ]
-    __guarded__ = [
-        "is_vip",
-        "payload",
-    ]
+    __fillable__ = ["due_date"]
+    __guarded__ = ["is_vip", "payload"]
 
 
 class InvalidFillableGuardedChildModelTest(ModelTest):
-    __fillable__ = [
-        "due_date",
-    ]
-    __guarded__ = [
-        "is_vip",
-        "payload",
-    ]
+    __fillable__ = ["due_date"]
+    __guarded__ = ["is_vip", "payload"]
 
 
 class ModelTestForced(Model):
@@ -147,9 +134,7 @@ def test_model_can_cast_dict_attributes(self):
 
     def test_valid_json_cast(self):
         model = ModelTest.hydrate(
-            {
-                "payload": {"this": "dict", "is": "usable", "as": "json"},
-            }
+            {"payload": {"this": "dict", "is": "usable", "as": "json"}}
         )
 
         self.assertEqual(type(model.payload), dict)

tests/mysql/model/test_model.py

@@ -113,10 +113,7 @@ def test_create_can_use_guarded_asterisk(self):
 
         # An asterisk guarded attribute excludes all fields from mass-assignment.
         # This would raise a DB error if there are any required fields.
-        self.assertEqual(
-            sql,
-            "INSERT INTO `profiles` (*) VALUES ()",
-        )
+        self.assertEqual(sql, "INSERT INTO `profiles` (*) VALUES ()")
 
     def test_bulk_create_can_use_fillable(self):
         query_builder = ProfileFillable.bulk_create(
@@ -173,8 +170,7 @@ def test_bulk_create_can_use_guarded_asterisk(self):
         # This would obviously raise an invalid SQL syntax error.
         # TODO: Raise a clearer error?
         self.assertEqual(
-            query_builder.to_sql(),
-            "INSERT INTO `profiles` () VALUES (), ()",
+            query_builder.to_sql(), "INSERT INTO `profiles` () VALUES (), ()"
         )
 
     def test_update_can_use_fillable(self):
@@ -214,10 +210,7 @@ def test_update_can_use_guarded_asterisk(self):
 
         # An asterisk guarded attribute excludes all fields from mass-assignment.
         # The query builder's sql should not have been altered in any way.
-        self.assertEqual(
-            query_builder.to_sql(),
-            initial_sql,
-        )
+        self.assertEqual(query_builder.to_sql(), initial_sql)
 
     def test_table_name(self):
         table_name = Profile.get_table_name()
@@ -250,25 +243,15 @@ def test_serialize_with_hidden(self):
 
     def test_serialize_with_visible(self):
         profile = ProfileSerializeWithVisible.hydrate(
-            {
-                "name": "Joe",
-                "id": 1,
-                "password": "secret",
-                "email": "[email protected]",
-            }
+            {"name": "Joe", "id": 1, "password": "secret", "email": "[email protected]"}
         )
         self.assertTrue(
             {"name": "Joe", "email": "[email protected]"}, profile.serialize()
         )
 
     def test_serialize_with_visible_and_hidden_raise_error(self):
         profile = ProfileSerializeWithVisibleAndHidden.hydrate(
-            {
-                "name": "Joe",
-                "id": 1,
-                "password": "secret",
-                "email": "[email protected]",
-            }
+            {"name": "Joe", "id": 1, "password": "secret", "email": "[email protected]"}
         )
         with self.assertRaises(AttributeError):
             profile.serialize()

tests/sqlite/models/test_sqlite_model.py

@@ -87,17 +87,13 @@ def test_find_or_if_record_not_found(self):
         record_id = 1_000_000_000_000_000
 
         result = User.find_or(record_id, lambda: "Record not found.")
-        self.assertEqual(
-            result, "Record not found."
-        )
+        self.assertEqual(result, "Record not found.")
 
     def test_find_or_if_record_found(self):
         record_id = 1
         result_id = User.find_or(record_id, lambda: "Record not found.").id
 
-        self.assertEqual(
-            result_id, record_id
-        )
+        self.assertEqual(result_id, record_id)
 
     def test_can_set_and_retreive_attribute(self):
         user = User.hydrate({"id": 1, "name": "joe", "customer_id": 1})