Ran black

Author: erezsh

data_diff/sqeleton/databases/databricks.py

@@ -13,7 +13,7 @@
     DbPath,
     ColType,
     UnknownColType,
-    Boolean
+    Boolean,
 )
 from ..abcs.mixins import AbstractMixin_MD5, AbstractMixin_NormalizeValue
 from .base import MD5_HEXDIGITS, CHECKSUM_HEXDIGITS, BaseDialect, ThreadedDatabase, import_helper, parse_table_name

data_diff/sqeleton/databases/oracle.py

@@ -59,15 +59,16 @@ def normalize_number(self, value: str, coltype: FractionalType) -> str:
             format_str += "0." + "9" * (coltype.precision - 1) + "0"
         return f"to_char({value}, '{format_str}')"
 
+
 class Mixin_Schema(AbstractMixin_Schema):
     def list_tables(self, table_schema: str, like: Compilable = None) -> Compilable:
         return (
-            table('ALL_TABLES')
+            table("ALL_TABLES")
             .where(
                 this.OWNER == table_schema,
                 this.TABLE_NAME.like(like) if like is not None else SKIP,
             )
-            .select(table_name = this.TABLE_NAME)
+            .select(table_name=this.TABLE_NAME)
         )
 
 

data_diff/table_segment.py

@@ -100,7 +100,9 @@ def source_table(self):
         return table(*self.table_path, schema=self._schema)
 
     def make_select(self):
-        return self.source_table.where(*self._make_key_range(), *self._make_update_range(), Code(self.where) if self.where else SKIP)
+        return self.source_table.where(
+            *self._make_key_range(), *self._make_update_range(), Code(self.where) if self.where else SKIP
+        )
 
     def get_values(self) -> list:
         "Download all the relevant values of the segment from the database"

tests/common.py

@@ -152,10 +152,10 @@ def setUp(self):
 
         if self.src_schema:
             self.src_table = table(self.table_src_path, schema=self.src_schema)
-            self.connection.query( self.src_table.create() )
+            self.connection.query(self.src_table.create())
         if self.dst_schema:
             self.dst_table = table(self.table_dst_path, schema=self.dst_schema)
-            self.connection.query( self.dst_table.create() )
+            self.connection.query(self.dst_table.create())
 
         return super().setUp()
 

tests/sqeleton/test_database.py

@@ -3,6 +3,7 @@
 
 from ..common import str_to_checksum, TEST_MYSQL_CONN_STRING
 from ..common import str_to_checksum, test_each_database_in_list, DiffTestCase, get_conn, random_table_suffix
+
 # from data_diff.sqeleton import databases as db
 # from data_diff.sqeleton import connect
 
@@ -53,16 +54,15 @@ def test_bad_uris(self):
 
 @test_each_database
 class TestSchema(unittest.TestCase):
-
     def test_table_list(self):
-        name = 'tbl_' + random_table_suffix()
+        name = "tbl_" + random_table_suffix()
         db = get_conn(self.db_cls)
-        tbl = table(db.parse_table_name(name), schema={'id': int})
+        tbl = table(db.parse_table_name(name), schema={"id": int})
         q = db.dialect.list_tables(db.default_schema, name)
         assert not db.query(q)
 
         db.query(tbl.create())
-        self.assertEqual( db.query(q, List[str] ), [name])
+        self.assertEqual(db.query(q, List[str]), [name])
 
-        db.query( tbl.drop() )
+        db.query(tbl.drop())
         assert not db.query(q)

tests/sqeleton/test_query.py

@@ -74,8 +74,7 @@ def test_basic(self):
         assert c.compile(t) == "SELECT * FROM point WHERE (x = 1) AND (y = 2)"
 
         t = table("person").where(this.name == "Albert")
-        self.assertEqual( c.compile(t), "SELECT * FROM person WHERE (name = 'Albert')" )
-
+        self.assertEqual(c.compile(t), "SELECT * FROM person WHERE (name = 'Albert')")
 
     def test_outerjoin(self):
         c = Compiler(MockDatabase())

tests/sqeleton/test_sql.py

@@ -73,7 +73,9 @@ def test_in(self):
         expected_sql = "SELECT name FROM `marine_mammals`.`walrus` WHERE (id IN (1, 2, 3))"
         self.assertEqual(
             expected_sql,
-            self.compiler.compile(Select(table("marine_mammals", "walrus"), [Code("name")], [In(Code("id"), [1, 2, 3])])),
+            self.compiler.compile(
+                Select(table("marine_mammals", "walrus"), [Code("name")], [In(Code("id"), [1, 2, 3])])
+            ),
         )
 
     def test_count(self):
@@ -87,7 +89,9 @@ def test_count_with_column(self):
         expected_sql = "SELECT count(id) FROM `marine_mammals`.`walrus` WHERE (id IN (1, 2, 3))"
         self.assertEqual(
             expected_sql,
-            self.compiler.compile(Select(table("marine_mammals", "walrus"), [Count(Code("id"))], [In(Code("id"), [1, 2, 3])])),
+            self.compiler.compile(
+                Select(table("marine_mammals", "walrus"), [Count(Code("id"))], [In(Code("id"), [1, 2, 3])])
+            ),
         )
 
     def test_explain(self):

tests/test_database_types.py

@@ -610,7 +610,7 @@ def _create_table_with_indexes(conn, table_path, type_):
         conn.query(tbl.create())
 
     if conn.dialect.SUPPORTS_INDEXES:
-        index_id ,= table_path
+        (index_id,) = table_path
         conn.query(f"CREATE INDEX xa_{index_id} ON {table_name} ({quote('id')}, {quote('col')})")
         conn.query(f"CREATE INDEX xb_{index_id} ON {table_name} ({quote('id')})")
 

tests/test_diff_tables.py

@@ -383,8 +383,12 @@ def setUp(self):
             ]
         )
 
-        self.a = _table_segment(self.connection, self.table_src_path, "id", extra_columns=("text_comment",), case_sensitive=False).with_schema()
-        self.b = _table_segment(self.connection, self.table_dst_path, "id", extra_columns=("text_comment",), case_sensitive=False).with_schema()
+        self.a = _table_segment(
+            self.connection, self.table_src_path, "id", extra_columns=("text_comment",), case_sensitive=False
+        ).with_schema()
+        self.b = _table_segment(
+            self.connection, self.table_dst_path, "id", extra_columns=("text_comment",), case_sensitive=False
+        ).with_schema()
 
     def test_string_keys(self):
         differ = HashDiffer(bisection_factor=2)
@@ -706,17 +710,13 @@ def setUp(self):
         self.b = _table_segment(self.connection, self.table_dst_path, "id", "text_comment", case_sensitive=False)
 
     def test_right_table_empty(self):
-        self.connection.query(
-            [self.src_table.insert_rows(self.diffs), commit]
-        )
+        self.connection.query([self.src_table.insert_rows(self.diffs), commit])
 
         differ = HashDiffer(bisection_factor=2)
         self.assertRaises(ValueError, list, differ.diff_tables(self.a, self.b))
 
     def test_left_table_empty(self):
-        self.connection.query(
-            [self.dst_table.insert_rows(self.diffs), commit]
-        )
+        self.connection.query([self.dst_table.insert_rows(self.diffs), commit])
 
         differ = HashDiffer(bisection_factor=2)
         self.assertRaises(ValueError, list, differ.diff_tables(self.a, self.b))
@@ -728,10 +728,12 @@ class TestInfoTree(DiffTestCase):
 
     def test_info_tree_root(self):
         db = self.connection
-        db.query([
-            self.src_table.insert_rows([i] for i in range(1000)),
-            self.dst_table.insert_rows([i] for i in range(2000)),
-        ])
+        db.query(
+            [
+                self.src_table.insert_rows([i] for i in range(1000)),
+                self.dst_table.insert_rows([i] for i in range(2000)),
+            ]
+        )
 
         ts1 = TableSegment(db, self.src_table.path, ("id",))
         ts2 = TableSegment(db, self.dst_table.path, ("id",))