Fix lint

Author: kjamrozy

libs/labelbox/src/labelbox/schema/ontology.py

@@ -155,6 +155,7 @@ def add_classification(self, classification: Classification) -> None:
             )
         self.classifications.append(classification)
 
+
 """
 The following 2 functions help to bridge the gap between the step reasoning all other tool ontologies.
 """

libs/labelbox/src/labelbox/schema/tool_building/relationship_tool.py

@@ -6,6 +6,7 @@
 
 from labelbox.schema.ontology import Tool
 
+
 @dataclass
 class RelationshipTool(Tool):
     """
@@ -44,7 +45,12 @@ class RelationshipTool(Tool):
 
     constraints: Optional[List[Tuple[str, str]]] = None
 
-    def __init__(self, name: str, constraints: Optional[List[Tuple[str, str]]] = None, **kwargs):
+    def __init__(
+        self,
+        name: str,
+        constraints: Optional[List[Tuple[str, str]]] = None,
+        **kwargs,
+    ):
         super().__init__(Tool.Type.RELATIONSHIP, name, **kwargs)
         if constraints is not None:
             self.constraints = constraints
@@ -57,7 +63,7 @@ def __post_init__(self):
     def asdict(self) -> Dict[str, Any]:
         result = super().asdict()
         if self.constraints is not None:
-            result["definition"] = { "constraints": self.constraints }
+            result["definition"] = {"constraints": self.constraints}
         return result
 
     def add_constraint(self, start: Tool, end: Tool) -> None:
@@ -77,8 +83,10 @@ def add_constraint(self, start: Tool, end: Tool) -> None:
         if end.schema_id is None:
             end.schema_id = str(uuid.uuid4())
 
-        self.constraints.append((start.feature_schema_id, end.feature_schema_id))
-    
+        self.constraints.append(
+            (start.feature_schema_id, end.feature_schema_id)
+        )
+
     def set_constraints(self, constraints: List[Tuple[Tool, Tool]]) -> None:
         self.constraints = []
         for constraint in constraints:

libs/labelbox/tests/unit/test_unit_relationship_tool.py

@@ -7,7 +7,7 @@
 
 def test_basic_instantiation():
     tool = RelationshipTool(name="Test Relationship Tool")
-    
+
     assert tool.name == "Test Relationship Tool"
     assert tool.tool == Tool.Type.RELATIONSHIP
     assert tool.constraints is None
@@ -20,26 +20,23 @@ def test_basic_instantiation():
 def test_instantiation_with_constraints():
     constraints = [
         ("source_id_1", "target_id_1"),
-        ("source_id_2", "target_id_2")
+        ("source_id_2", "target_id_2"),
     ]
     tool = RelationshipTool(name="Test Tool", constraints=constraints)
-    
+
     assert tool.name == "Test Tool"
     assert tool.constraints == constraints
     assert len(tool.constraints) == 2
 
+
 def test_post_init_sets_tool_type():
     tool = RelationshipTool(name="Test Tool")
     assert tool.tool == Tool.Type.RELATIONSHIP
 
 
 def test_asdict_without_constraints():
-    tool = RelationshipTool(
-        name="Test Tool",
-        required=True,
-        color="#FF0000"
-    )
-    
+    tool = RelationshipTool(name="Test Tool", required=True, color="#FF0000")
+
     result = tool.asdict()
     expected = {
         "tool": "edge",
@@ -49,17 +46,18 @@ def test_asdict_without_constraints():
         "classifications": [],
         "schemaNodeId": None,
         "featureSchemaId": None,
-        "attributes": None
+        "attributes": None,
     }
-    
+
     assert result == expected
 
+
 def test_asdict_with_constraints():
     constraints = [("source_id", "target_id")]
     tool = RelationshipTool(name="Test Tool", constraints=constraints)
-    
+
     result = tool.asdict()
-    
+
     assert "definition" in result
     assert result["definition"] == {"constraints": constraints}
     assert result["tool"] == "edge"
@@ -70,11 +68,11 @@ def test_add_constraint_to_empty_constraints():
     tool = RelationshipTool(name="Test Tool")
     start_tool = Tool(Tool.Type.BBOX, "Start Tool")
     end_tool = Tool(Tool.Type.POLYGON, "End Tool")
-    
-    with patch('uuid.uuid4') as mock_uuid:
+
+    with patch("uuid.uuid4") as mock_uuid:
         mock_uuid.return_value.hex = "test-uuid"
         tool.add_constraint(start_tool, end_tool)
-    
+
     assert tool.constraints is not None
     assert len(tool.constraints) == 1
     assert start_tool.feature_schema_id is not None
@@ -86,87 +84,108 @@ def test_add_constraint_to_empty_constraints():
 def test_add_constraint_to_existing_constraints():
     existing_constraints = [("existing_source", "existing_target")]
     tool = RelationshipTool(name="Test Tool", constraints=existing_constraints)
-    
+
     start_tool = Tool(Tool.Type.BBOX, "Start Tool")
     end_tool = Tool(Tool.Type.POLYGON, "End Tool")
-    
+
     tool.add_constraint(start_tool, end_tool)
-    
+
     assert len(tool.constraints) == 2
     assert tool.constraints[0] == ("existing_source", "existing_target")
-    assert tool.constraints[1] == (start_tool.feature_schema_id, end_tool.feature_schema_id)
+    assert tool.constraints[1] == (
+        start_tool.feature_schema_id,
+        end_tool.feature_schema_id,
+    )
 
 
 def test_add_constraint_preserves_existing_ids():
     tool = RelationshipTool(name="Test Tool")
     start_tool_feature_schema_id = "start_tool_feature_schema_id"
     start_tool_schema_id = "start_tool_schema_id"
-    start_tool = Tool(Tool.Type.BBOX, "Start Tool", feature_schema_id=start_tool_feature_schema_id, schema_id=start_tool_schema_id)
+    start_tool = Tool(
+        Tool.Type.BBOX,
+        "Start Tool",
+        feature_schema_id=start_tool_feature_schema_id,
+        schema_id=start_tool_schema_id,
+    )
     end_tool_feature_schema_id = "end_tool_feature_schema_id"
     end_tool_schema_id = "end_tool_schema_id"
-    end_tool = Tool(Tool.Type.POLYGON, "End Tool", feature_schema_id=end_tool_feature_schema_id, schema_id=end_tool_schema_id)
+    end_tool = Tool(
+        Tool.Type.POLYGON,
+        "End Tool",
+        feature_schema_id=end_tool_feature_schema_id,
+        schema_id=end_tool_schema_id,
+    )
 
     tool.add_constraint(start_tool, end_tool)
-    
+
     assert start_tool.feature_schema_id == start_tool_feature_schema_id
     assert start_tool.schema_id == start_tool_schema_id
     assert end_tool.feature_schema_id == end_tool_feature_schema_id
     assert end_tool.schema_id == end_tool_schema_id
-    assert tool.constraints == [(start_tool_feature_schema_id, end_tool_feature_schema_id)]
+    assert tool.constraints == [
+        (start_tool_feature_schema_id, end_tool_feature_schema_id)
+    ]
 
 
 def test_set_constraints():
     tool = RelationshipTool(name="Test Tool")
-    
+
     start_tool1 = Tool(Tool.Type.BBOX, "Start Tool 1")
     end_tool1 = Tool(Tool.Type.POLYGON, "End Tool 1")
     start_tool2 = Tool(Tool.Type.POINT, "Start Tool 2")
     end_tool2 = Tool(Tool.Type.LINE, "End Tool 2")
-    
-    tool.set_constraints([
-        (start_tool1, end_tool1),
-        (start_tool2, end_tool2)
-    ])
-    
+
+    tool.set_constraints([(start_tool1, end_tool1), (start_tool2, end_tool2)])
+
     assert len(tool.constraints) == 2
-    assert tool.constraints[0] == (start_tool1.feature_schema_id, end_tool1.feature_schema_id)
-    assert tool.constraints[1] == (start_tool2.feature_schema_id, end_tool2.feature_schema_id)
+    assert tool.constraints[0] == (
+        start_tool1.feature_schema_id,
+        end_tool1.feature_schema_id,
+    )
+    assert tool.constraints[1] == (
+        start_tool2.feature_schema_id,
+        end_tool2.feature_schema_id,
+    )
 
 
 def test_set_constraints_replaces_existing():
     existing_constraints = [("old_source", "old_target")]
     tool = RelationshipTool(name="Test Tool", constraints=existing_constraints)
-    
+
     start_tool = Tool(Tool.Type.BBOX, "Start Tool")
     end_tool = Tool(Tool.Type.POLYGON, "End Tool")
-    
+
     tool.set_constraints([(start_tool, end_tool)])
-    
+
     assert len(tool.constraints) == 1
     assert tool.constraints[0] != ("old_source", "old_target")
-    assert tool.constraints[0] == (start_tool.feature_schema_id, end_tool.feature_schema_id)
+    assert tool.constraints[0] == (
+        start_tool.feature_schema_id,
+        end_tool.feature_schema_id,
+    )
 
 
 def test_uuid_generation_in_add_constraint():
     tool = RelationshipTool(name="Test Tool")
-    
+
     start_tool = Tool(Tool.Type.BBOX, "Start Tool")
     end_tool = Tool(Tool.Type.POLYGON, "End Tool")
-    
+
     # Ensure tools don't have IDs initially
     assert start_tool.feature_schema_id is None
     assert start_tool.schema_id is None
     assert end_tool.feature_schema_id is None
     assert end_tool.schema_id is None
-    
+
     tool.add_constraint(start_tool, end_tool)
-    
+
     # Check that UUIDs were generated
     assert start_tool.feature_schema_id is not None
     assert start_tool.schema_id is not None
     assert end_tool.feature_schema_id is not None
     assert end_tool.schema_id is not None
-    
+
     # Check that they are valid UUID strings
     uuid.UUID(start_tool.feature_schema_id)  # Will raise ValueError if invalid
     uuid.UUID(start_tool.schema_id)
@@ -176,18 +195,18 @@ def test_uuid_generation_in_add_constraint():
 
 def test_constraints_in_asdict():
     tool = RelationshipTool(name="Test Tool")
-    
+
     start_tool = Tool(Tool.Type.BBOX, "Start Tool")
     end_tool = Tool(Tool.Type.POLYGON, "End Tool")
-    
+
     tool.add_constraint(start_tool, end_tool)
-    
+
     result = tool.asdict()
-    
+
     assert "definition" in result
     assert "constraints" in result["definition"]
     assert len(result["definition"]["constraints"]) == 1
     assert result["definition"]["constraints"][0] == (
         start_tool.feature_schema_id,
-        end_tool.feature_schema_id
+        end_tool.feature_schema_id,
     )