Apply ruff format

Author: kislyuk

docs/conf.py

@@ -22,6 +22,6 @@
         "logo-text.html",
         # "globaltoc.html",
         "localtoc.html",
-        "searchbox.html"
+        "searchbox.html",
     ]
 }

setup.py

@@ -5,37 +5,33 @@
 setup(
     name="sqlalchemy-aurora-data-api",
     version="0.4.1",
-    url='https://github.com/chanzuckerberg/sqlalchemy-aurora-data-api',
-    license='Apache Software License',
-    author='Andrey Kislyuk',
-    author_email='[email protected]',
-    description='An AWS Aurora Serverless Data API dialect for SQLAlchemy',
-    long_description=open('README.rst').read(),
-    install_requires=[
-        'sqlalchemy',
-        'aurora-data-api >= 0.4.0'
-    ],
-    extras_require={
-    },
-    packages=find_packages(exclude=['test']),
+    url="https://github.com/chanzuckerberg/sqlalchemy-aurora-data-api",
+    license="Apache Software License",
+    author="Andrey Kislyuk",
+    author_email="[email protected]",
+    description="An AWS Aurora Serverless Data API dialect for SQLAlchemy",
+    long_description=open("README.rst").read(),
+    install_requires=["sqlalchemy", "aurora-data-api >= 0.4.0"],
+    extras_require={},
+    packages=find_packages(exclude=["test"]),
     entry_points={
-        'sqlalchemy.dialects': [
-            'mysql.auroradataapi = sqlalchemy_aurora_data_api:AuroraMySQLDataAPIDialect',
-            'postgresql.auroradataapi = sqlalchemy_aurora_data_api:AuroraPostgresDataAPIDialect'
+        "sqlalchemy.dialects": [
+            "mysql.auroradataapi = sqlalchemy_aurora_data_api:AuroraMySQLDataAPIDialect",
+            "postgresql.auroradataapi = sqlalchemy_aurora_data_api:AuroraPostgresDataAPIDialect",
         ]
     },
-    platforms=['MacOS X', 'Posix'],
-    test_suite='test',
+    platforms=["MacOS X", "Posix"],
+    test_suite="test",
     classifiers=[
-        'Intended Audience :: Developers',
-        'License :: OSI Approved :: Apache Software License',
-        'Operating System :: MacOS :: MacOS X',
-        'Operating System :: POSIX',
-        'Programming Language :: Python',
-        'Programming Language :: Python :: 3.5',
-        'Programming Language :: Python :: 3.6',
-        'Programming Language :: Python :: 3.7',
-        'Programming Language :: Python :: 3.8',
-        'Topic :: Software Development :: Libraries :: Python Modules'
-    ]
+        "Intended Audience :: Developers",
+        "License :: OSI Approved :: Apache Software License",
+        "Operating System :: MacOS :: MacOS X",
+        "Operating System :: POSIX",
+        "Programming Language :: Python",
+        "Programming Language :: Python :: 3.5",
+        "Programming Language :: Python :: 3.6",
+        "Programming Language :: Python :: 3.7",
+        "Programming Language :: Python :: 3.8",
+        "Topic :: Software Development :: Libraries :: Python Modules",
+    ],
 )

sqlalchemy_aurora_data_api/__init__.py

@@ -50,6 +50,7 @@ def ms(value):
     def bind_processor(self, dialect):
         def process(value):
             return value.isoformat() if isinstance(value, self.py_type) else value
+
         return process
 
     def bind_expression(self, value):
@@ -74,6 +75,7 @@ def process(value):
                         return datetime.datetime.strptime(value, "%Y-%m-%d %H:%M:%S.%f")
                     return datetime.datetime.strptime(value, "%Y-%m-%d %H:%M:%S")
             return value
+
         return process
 
 
@@ -84,6 +86,7 @@ class _ADA_DATE(_ADA_DATETIME_MIXIN, DATE):
     def bind_processor(self, dialect):
         def process(value):
             return value.strftime("%Y-%m-%d") if isinstance(value, self.py_type) else value
+
         return process
 
 
@@ -94,6 +97,7 @@ class _ADA_TIME(_ADA_DATETIME_MIXIN, TIME):
     def bind_processor(self, dialect):
         def process(value):
             return value.strftime("%H:%M:%S.") + self.ms(value) if isinstance(value, self.py_type) else value
+
         return process
 
 
@@ -104,6 +108,7 @@ class _ADA_TIMESTAMP(_ADA_DATETIME_MIXIN, TIMESTAMP):
     def bind_processor(self, dialect):
         def process(value):
             return value.strftime("%Y-%m-%d %H:%M:%S.") + self.ms(value) if isinstance(value, self.py_type) else value
+
         return process
 
 
@@ -112,6 +117,7 @@ def bind_processor(self, dialect):
         def process(value):
             # FIXME: escape strings properly here
             return "\v".join(value) if isinstance(value, list) else value
+
         return process
 
     def bind_expression(self, value):
@@ -123,11 +129,14 @@ class AuroraMySQLDataAPIDialect(MySQLDialect):
     driver = "aurora_data_api"
     default_schema_name = None
     supports_native_decimal = True
-    colspecs = util.update_copy(MySQLDialect.colspecs, {
-        sqltypes.Date: _ADA_DATE,
-        sqltypes.Time: _ADA_TIME,
-        sqltypes.DateTime: _ADA_TIMESTAMP,
-    })
+    colspecs = util.update_copy(
+        MySQLDialect.colspecs,
+        {
+            sqltypes.Date: _ADA_DATE,
+            sqltypes.Time: _ADA_TIME,
+            sqltypes.DateTime: _ADA_TIMESTAMP,
+        },
+    )
     supports_statement_cache = True
 
     @classmethod
@@ -145,17 +154,20 @@ class AuroraPostgresDataAPIDialect(PGDialect):
     # See https://docs.sqlalchemy.org/en/13/core/internals.html#sqlalchemy.engine.interfaces.Dialect
     driver = "aurora_data_api"
     default_schema_name = None
-    colspecs = util.update_copy(PGDialect.colspecs, {
-        sqltypes.JSON: _ADA_SA_JSON,
-        JSON: _ADA_JSON,
-        JSONB: _ADA_JSONB,
-        UUID: _ADA_UUID,
-        sqltypes.Date: _ADA_DATE,
-        sqltypes.Time: _ADA_TIME,
-        sqltypes.DateTime: _ADA_TIMESTAMP,
-        sqltypes.Enum: _ADA_ENUM,
-        ARRAY: _ADA_ARRAY
-    })
+    colspecs = util.update_copy(
+        PGDialect.colspecs,
+        {
+            sqltypes.JSON: _ADA_SA_JSON,
+            JSON: _ADA_JSON,
+            JSONB: _ADA_JSONB,
+            UUID: _ADA_UUID,
+            sqltypes.Date: _ADA_DATE,
+            sqltypes.Time: _ADA_TIME,
+            sqltypes.DateTime: _ADA_TIMESTAMP,
+            sqltypes.Enum: _ADA_ENUM,
+            ARRAY: _ADA_ARRAY,
+        },
+    )
     supports_sane_multi_rowcount = False
     supports_statement_cache = True
 
@@ -169,5 +181,6 @@ def _extract_error_code(self, exception):
 
 def register_dialects():
     from sqlalchemy.dialects import registry
+
     registry.register("mysql.auroradataapi", __name__, AuroraMySQLDataAPIDialect.__name__)
     registry.register("postgresql.auroradataapi", __name__, AuroraPostgresDataAPIDialect.__name__)

test/test.py

@@ -6,8 +6,21 @@
 import enum
 from uuid import UUID as uuid_type, uuid4
 
-from sqlalchemy import (create_engine, Column, Integer, String, Boolean, Float, LargeBinary, Numeric, Date, Time,
-                        DateTime, Text, Enum)
+from sqlalchemy import (
+    create_engine,
+    Column,
+    Integer,
+    String,
+    Boolean,
+    Float,
+    LargeBinary,
+    Numeric,
+    Date,
+    Time,
+    DateTime,
+    Text,
+    Enum,
+)
 from sqlalchemy.dialects.postgresql import UUID, JSONB, JSON, DATE, TIME, TIMESTAMP, ARRAY
 from sqlalchemy.ext.declarative import declarative_base
 from sqlalchemy.orm import sessionmaker
@@ -48,7 +61,7 @@
     "sequences_optional",
     "supports_native_enum",
     "supports_native_boolean",
-    "dbapi_exception_translation_map"
+    "dbapi_exception_translation_map",
 }
 
 dialect_interface_methods = {
@@ -94,7 +107,7 @@
     # "reflect_table",
     "reset_isolation_level",
     "set_isolation_level",
-    "type_descriptor"
+    "type_descriptor",
 }
 
 BasicBase = declarative_base()
@@ -166,7 +179,7 @@ class TestAuroraDataAPIPostgresDialect(TestAuroraDataAPI):
     def setUpClass(cls):
         register_dialects()
         cls.db_name = os.environ.get("AURORA_DB_NAME", __name__)
-        cls.engine = create_engine(cls.dialect + ':@/' + cls.db_name)
+        cls.engine = create_engine(cls.dialect + ":@/" + cls.db_name)
 
     def test_execute(self):
         with self.engine.connect() as conn:
@@ -175,26 +188,41 @@ def test_execute(self):
 
     def test_orm(self):
         uuid = uuid4()
-        doc = {'foo': [1, 2, 3]}
+        doc = {"foo": [1, 2, 3]}
         blob = b"0123456789ABCDEF" * 1024
         friends = ["Scarlett O'Hara", 'Ada "Hacker" Lovelace']
         Base.metadata.create_all(self.engine)
         added = datetime.datetime.now().replace(microsecond=123456)
-        ed_user = User(name='ed', fullname='Ed Jones', nickname='edsnickname', doc=doc, doc2=doc, uuid=str(uuid),
-                       flag=True, birthday=datetime.datetime.fromtimestamp(0), added=added, floated=1.2, nybbled=blob,
-                       friends=friends, num_friends=500, num_laptops=9000, first_date=added, note='note',
-                       socks=Socks.red)
+        ed_user = User(
+            name="ed",
+            fullname="Ed Jones",
+            nickname="edsnickname",
+            doc=doc,
+            doc2=doc,
+            uuid=str(uuid),
+            flag=True,
+            birthday=datetime.datetime.fromtimestamp(0),
+            added=added,
+            floated=1.2,
+            nybbled=blob,
+            friends=friends,
+            num_friends=500,
+            num_laptops=9000,
+            first_date=added,
+            note="note",
+            socks=Socks.red,
+        )
         Session = sessionmaker(bind=self.engine)
         session = Session()
 
         session.query(User).delete()
         session.commit()
 
         session.add(ed_user)
-        self.assertEqual(session.query(User).filter_by(name='ed').first().name, "ed")
+        self.assertEqual(session.query(User).filter_by(name="ed").first().name, "ed")
         session.commit()
-        self.assertGreater(session.query(User).filter(User.name.like('%ed')).count(), 0)
-        u = session.query(User).filter(User.name.like('%ed')).first()
+        self.assertGreater(session.query(User).filter(User.name.like("%ed")).count(), 0)
+        u = session.query(User).filter(User.name.like("%ed")).first()
         self.assertEqual(u.doc, doc)
         self.assertEqual(u.doc2, doc)
         self.assertEqual(u.flag, True)
@@ -207,7 +235,7 @@ def test_orm(self):
         self.assertEqual(u.num_friends, 500)
         self.assertEqual(u.num_laptops, 9000)
         self.assertEqual(u.first_date, added.date())
-        self.assertEqual(u.note, 'note')
+        self.assertEqual(u.note, "note")
         self.assertEqual(u.socks, Socks.red)
         self.assertEqual(u.uuid, str(uuid))
         self.assertIsInstance(u.uuid2, uuid_type)
@@ -216,12 +244,12 @@ def test_orm(self):
         session.commit()
 
         session2 = Session()
-        u2 = session2.query(User).filter(User.name.like('%ed')).first()
+        u2 = session2.query(User).filter(User.name.like("%ed")).first()
         self.assertEqual(u2.socks, Socks.green)
 
     @unittest.skipIf(sys.version_info < (3, 7), "Skipping test that requires Python 3.7+")
     def test_timestamp_microsecond_padding(self):
-        ts = '2019-10-31 09:37:17.3186'
+        ts = "2019-10-31 09:37:17.3186"
         processor = _ADA_TIMESTAMP.result_processor(_ADA_TIMESTAMP, None, None)
         self.assertEqual(processor(ts), datetime.datetime.fromisoformat(ts.ljust(26, "0")))
 
@@ -233,7 +261,7 @@ class TestAuroraDataAPIMySQLDialect(TestAuroraDataAPI):
     def setUpClass(cls):
         register_dialects()
         cls.db_name = os.environ.get("AURORA_DB_NAME", __name__)
-        cls.engine = create_engine(cls.dialect + ':@/' + cls.db_name + "?charset=utf8mb4")
+        cls.engine = create_engine(cls.dialect + ":@/" + cls.db_name + "?charset=utf8mb4")
 
     def test_execute(self):
         with self.engine.connect() as conn:
@@ -245,19 +273,25 @@ def test_orm(self):
         birthday = datetime.datetime.fromtimestamp(0).date()
         eats_breakfast_at = datetime.time(9, 0, 0, 123)
         married_at = datetime.datetime(2020, 2, 20, 2, 20, 2, 200200)
-        ed_user = BasicUser(name='ed', fullname='Ed Jones', nickname='edsnickname',
-                            birthday=birthday, eats_breakfast_at=eats_breakfast_at, married_at=married_at)
+        ed_user = BasicUser(
+            name="ed",
+            fullname="Ed Jones",
+            nickname="edsnickname",
+            birthday=birthday,
+            eats_breakfast_at=eats_breakfast_at,
+            married_at=married_at,
+        )
         Session = sessionmaker(bind=self.engine)
         session = Session()
 
         session.query(BasicUser).delete()
         session.commit()
 
         session.add(ed_user)
-        self.assertEqual(session.query(BasicUser).filter_by(name='ed').first().name, "ed")
+        self.assertEqual(session.query(BasicUser).filter_by(name="ed").first().name, "ed")
         session.commit()
-        self.assertGreater(session.query(BasicUser).filter(BasicUser.name.like('%ed')).count(), 0)
-        u = session.query(BasicUser).filter(BasicUser.name.like('%ed')).first()
+        self.assertGreater(session.query(BasicUser).filter(BasicUser.name.like("%ed")).count(), 0)
+        u = session.query(BasicUser).filter(BasicUser.name.like("%ed")).first()
         self.assertEqual(u.nickname, "edsnickname")
         self.assertEqual(u.birthday, birthday)
         self.assertEqual(u.eats_breakfast_at, eats_breakfast_at.replace(microsecond=0))