Fix CI lint/format and type check failures

- Sort imports in conftest.py, test_social_network_queries.py
- Remove unused import TypeDBException in test_crud_edge_cases.py
- Fix E721: use `is not` instead of `== Profile` for type comparison
- Fix W293: remove whitespace from blank line in typedb_lifecycle.py
- Fix pyright error: use len(manager.all()) instead of manager.count()
- Format all test files with ruff

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

Author: CaliLuke

tests/integration/conftest.py

@@ -3,14 +3,14 @@
 import pytest
 from typedb.driver import DriverOptions
 
-from type_bridge import Credentials, Database, TypeDB
 from tests.utils.typedb_lifecycle import (
-    suppress_stderr,
+    TEST_DB_ADDRESS,
+    TEST_DB_NAME,
     start_typedb_container,
     stop_typedb_container,
-    TEST_DB_NAME,
-    TEST_DB_ADDRESS,
+    suppress_stderr,
 )
+from type_bridge import Credentials, Database, TypeDB
 
 
 @pytest.fixture(scope="session")

tests/integration/crud/test_complex_relations.py

@@ -188,9 +188,13 @@ def test_multiple_three_role_relations(self, schema_with_three_roles):
         Location.manager(db).insert(store)
 
         # Multiple purchases at same store
-        Purchase.manager(db).insert(Purchase(buyer=alice, item=laptop, store=store, amount=Amount(1)))
+        Purchase.manager(db).insert(
+            Purchase(buyer=alice, item=laptop, store=store, amount=Amount(1))
+        )
         Purchase.manager(db).insert(Purchase(buyer=bob, item=phone, store=store, amount=Amount(2)))
-        Purchase.manager(db).insert(Purchase(buyer=alice, item=phone, store=store, amount=Amount(1)))
+        Purchase.manager(db).insert(
+            Purchase(buyer=alice, item=phone, store=store, amount=Amount(1))
+        )
 
         purchases = Purchase.manager(db).all()
         assert len(purchases) == 3

tests/integration/crud/test_crud_edge_cases.py

@@ -5,7 +5,6 @@
 """
 
 import pytest
-from typedb.driver import TypeDBException
 
 from type_bridge import (
     Card,

tests/integration/generator/test_generate_and_import.py

@@ -439,26 +439,25 @@ def test_bounded_cardinality_role(self, generated_package: dict[str, ModuleType]
         assert reviewer_role.cardinality.min == 1
         assert reviewer_role.cardinality.max == 3
 
-    def test_create_relation_with_list_players(self, generated_package: dict[str, ModuleType]) -> None:
+    def test_create_relation_with_list_players(
+        self, generated_package: dict[str, ModuleType]
+    ) -> None:
         """Create relation instance with list of role players."""
         entities = generated_package["entities"]
         relations = generated_package["relations"]
         attributes = generated_package["attributes"]
 
         # Create two memory instances
         memory1 = entities.Memory(
-            name=attributes.Name("Memory 1"),
-            content=attributes.Content("First memory content")
+            name=attributes.Name("Memory 1"), content=attributes.Content("First memory content")
         )
         memory2 = entities.Memory(
-            name=attributes.Name("Memory 2"),
-            content=attributes.Content("Second memory content")
+            name=attributes.Name("Memory 2"), content=attributes.Content("Second memory content")
         )
 
         # Create similarity relation with list of players
         similarity = relations.Is_similar_to(
-            similar_memory=[memory1, memory2],
-            score=attributes.Score(0.95)
+            similar_memory=[memory1, memory2], score=attributes.Score(0.95)
         )
 
         assert similarity.similar_memory == [memory1, memory2]
@@ -480,7 +479,9 @@ def test_symmetric_friendship_with_list(self, generated_package: dict[str, Modul
         assert alice in friendship.friend
         assert bob in friendship.friend
 
-    def test_unbounded_role_with_multiple_players(self, generated_package: dict[str, ModuleType]) -> None:
+    def test_unbounded_role_with_multiple_players(
+        self, generated_package: dict[str, ModuleType]
+    ) -> None:
         """Group membership with 3+ members."""
         entities = generated_package["entities"]
         relations = generated_package["relations"]
@@ -491,10 +492,7 @@ def test_unbounded_role_with_multiple_players(self, generated_package: dict[str,
         member2 = entities.Person(name=attributes.Name("Member 2"))
         member3 = entities.Person(name=attributes.Name("Member 3"))
 
-        membership = relations.Group_membership(
-            group=group,
-            member=[member1, member2, member3]
-        )
+        membership = relations.Group_membership(group=group, member=[member1, member2, member3])
 
         assert membership.group == group
         assert len(membership.member) == 3

tests/integration/generator/test_generator_use_pipeline.py

@@ -86,7 +86,9 @@ def generated_package(self, tmp_path: Path) -> dict[str, ModuleType]:
         return _import_generated_package(output)
 
     @pytest.fixture
-    def db_with_generated_schema(self, clean_db: Database, generated_package: dict[str, ModuleType]):
+    def db_with_generated_schema(
+        self, clean_db: Database, generated_package: dict[str, ModuleType]
+    ):
         """Set up database with generated schema."""
         entities = generated_package["entities"]
         relations = generated_package["relations"]
@@ -297,7 +299,9 @@ def test_unbounded_cardinality_group_membership(
 
 
 @pytest.mark.integration
-@pytest.mark.skip(reason="Bookstore schema has @card constraints that need SchemaManager investigation")
+@pytest.mark.skip(
+    reason="Bookstore schema has @card constraints that need SchemaManager investigation"
+)
 class TestGeneratorBookstoreE2E:
     """Test bookstore schema end-to-end with various attribute types."""
 
@@ -311,7 +315,9 @@ def generated_package(self, tmp_path: Path) -> dict[str, ModuleType]:
         return _import_generated_package(output)
 
     @pytest.fixture
-    def db_with_bookstore_schema(self, clean_db: Database, generated_package: dict[str, ModuleType]):
+    def db_with_bookstore_schema(
+        self, clean_db: Database, generated_package: dict[str, ModuleType]
+    ):
         """Set up database with bookstore schema."""
         entities = generated_package["entities"]
         relations = generated_package["relations"]

tests/integration/queries/test_complex_graph.py

@@ -274,9 +274,17 @@ def test_count_with_filter(self, schema_for_aggregation):
         manager = Employee.manager(db)
 
         # Insert employees in different departments
-        manager.insert(Employee(name=Name("Alice"), salary=Salary(100000), department=Department("Engineering")))
-        manager.insert(Employee(name=Name("Bob"), salary=Salary(90000), department=Department("Engineering")))
-        manager.insert(Employee(name=Name("Carol"), salary=Salary(80000), department=Department("Marketing")))
+        manager.insert(
+            Employee(
+                name=Name("Alice"), salary=Salary(100000), department=Department("Engineering")
+            )
+        )
+        manager.insert(
+            Employee(name=Name("Bob"), salary=Salary(90000), department=Department("Engineering"))
+        )
+        manager.insert(
+            Employee(name=Name("Carol"), salary=Salary(80000), department=Department("Marketing"))
+        )
 
         # Count engineering employees
         eng_count = manager.filter(department="Engineering").count()
@@ -292,9 +300,17 @@ def test_multiple_filters_combined(self, schema_for_aggregation):
 
         manager = Employee.manager(db)
 
-        manager.insert(Employee(name=Name("Alice"), salary=Salary(100000), department=Department("Engineering")))
-        manager.insert(Employee(name=Name("Bob"), salary=Salary(60000), department=Department("Engineering")))
-        manager.insert(Employee(name=Name("Carol"), salary=Salary(90000), department=Department("Marketing")))
+        manager.insert(
+            Employee(
+                name=Name("Alice"), salary=Salary(100000), department=Department("Engineering")
+            )
+        )
+        manager.insert(
+            Employee(name=Name("Bob"), salary=Salary(60000), department=Department("Engineering"))
+        )
+        manager.insert(
+            Employee(name=Name("Carol"), salary=Salary(90000), department=Department("Marketing"))
+        )
 
         # All employees - use filter() to get a Query that has count()
         all_count = manager.filter().count()

tests/integration/queries/test_social_network_queries.py

@@ -29,7 +29,6 @@
     Unique,
 )
 
-
 # =============================================================================
 # Shared Attribute Types
 # =============================================================================
@@ -575,7 +574,7 @@ def test_insert_relation_with_person_author(self, schema_with_polymorphic_roles)
         # not the abstract declared type (Profile)
         author = authorings[0].author
         assert isinstance(author, Person), f"Expected Person, got {type(author).__name__}"
-        assert not type(author) == Profile  # Should NOT be the abstract type
+        assert type(author) is not Profile  # Should NOT be the abstract type
 
         # Inherited attributes from Profile are accessible
         assert str(author.profile_id) == "alice"
@@ -616,7 +615,7 @@ def test_insert_relation_with_org_author(self, schema_with_polymorphic_roles):
         assert isinstance(author, Organization), (
             f"Expected Organization, got {type(author).__name__}"
         )
-        assert not type(author) == Profile
+        assert type(author) is not Profile
 
         # Inherited attributes from Profile
         assert str(author.profile_id) == "techcorp"

tests/unit/generator/test_generator.py

@@ -545,7 +545,10 @@ def test_role_cardinality_exact(self) -> None:
         source = render_relations(schema, attr_names, entity_names, relation_names)
 
         # Role with @card(2..2) should include cardinality=Card(2, 2)
-        assert 'similar_memory: Role[entities.Memory] = Role("similar_memory", entities.Memory, cardinality=Card(2, 2))' in source
+        assert (
+            'similar_memory: Role[entities.Memory] = Role("similar_memory", entities.Memory, cardinality=Card(2, 2))'
+            in source
+        )
         assert "Card" in source
 
     def test_role_cardinality_unbounded(self) -> None:
@@ -565,7 +568,10 @@ def test_role_cardinality_unbounded(self) -> None:
         source = render_relations(schema, attr_names, entity_names, relation_names)
 
         # Role with @card(2..) should include cardinality=Card(2) (unbounded)
-        assert 'member: Role[entities.Person] = Role("member", entities.Person, cardinality=Card(2))' in source
+        assert (
+            'member: Role[entities.Person] = Role("member", entities.Person, cardinality=Card(2))'
+            in source
+        )
 
     def test_role_cardinality_bounded(self) -> None:
         """Render relation with bounded role cardinality (@card(1..3))."""
@@ -587,7 +593,10 @@ def test_role_cardinality_bounded(self) -> None:
         source = render_relations(schema, attr_names, entity_names, relation_names)
 
         # Role with @card(1..3) should include cardinality=Card(1, 3)
-        assert 'reviewer: Role[entities.Reviewer] = Role("reviewer", entities.Reviewer, cardinality=Card(1, 3))' in source
+        assert (
+            'reviewer: Role[entities.Reviewer] = Role("reviewer", entities.Reviewer, cardinality=Card(1, 3))'
+            in source
+        )
         # Role with @card(1) is default, should not include Card
         assert 'document: Role[entities.Document] = Role("document", entities.Document)' in source
 

tests/utils/assertions.py

@@ -12,7 +12,7 @@ def assert_entity_exists(db: Database, entity_type: type[Entity], **attrs) -> En
 def assert_entity_count(db: Database, entity_type: type[Entity], expected: int) -> None:
     """Assert the count of entities matches expected."""
     manager = entity_type.manager(db)
-    actual = manager.count()
+    actual = len(manager.all())
     assert actual == expected, f"Expected {expected} {entity_type.__name__}, got {actual}"
 
 
@@ -27,5 +27,5 @@ def assert_relation_exists(db: Database, relation_type: type[Relation], **role_p
 def assert_relation_count(db: Database, relation_type: type[Relation], expected: int) -> None:
     """Assert the count of relations matches expected."""
     manager = relation_type.manager(db)
-    actual = manager.count()
+    actual = len(manager.all())
     assert actual == expected, f"Expected {expected} {relation_type.__name__}, got {actual}"

tests/utils/data_builders.py

@@ -26,6 +26,7 @@ def make_email(name: str | None = None) -> str:
 def make_isbn() -> str:
     """Generate a fake ISBN-13."""
     import random
+
     # Generate 12 random digits
     digits = [random.randint(0, 9) for _ in range(12)]
     # Calculate check digit (simplified)