run black on tests

Author: gonzalocasas

tests/compas/data/test_json.py

@@ -69,9 +69,7 @@ def test_json_network():
 
 
 def test_json_mesh():
-    before = Mesh.from_vertices_and_faces(
-        [[0, 0, 0], [1, 0, 0], [1, 1, 0], [0, 1, 0]], [[0, 1, 2, 3]]
-    )
+    before = Mesh.from_vertices_and_faces([[0, 0, 0], [1, 0, 0], [1, 1, 0], [0, 1, 0]], [[0, 1, 2, 3]])
     after = compas.json_loads(compas.json_dumps(before))
     assert before.dtype == after.dtype
     assert before.attributes == after.attributes
@@ -81,10 +79,7 @@ def test_json_mesh():
     assert all(after.has_face(face) for face in before.faces())
     assert all(before.has_edge(edge) for edge in after.edges())
     assert all(after.has_edge(edge) for edge in before.edges())
-    assert all(
-        before.face_vertices(a) == after.face_vertices(b)
-        for a, b in zip(before.faces(), after.faces())
-    )
+    assert all(before.face_vertices(a) == after.face_vertices(b) for a, b in zip(before.faces(), after.faces()))
     assert before.guid == after.guid
 
 

tests/compas/data/test_jsonschema.py

@@ -215,9 +215,7 @@ def test_schema_vector_invalid(vector_validator, vector):
     def test_schema_line_valid(line_validator, line):
         line_validator.validate(line)
 
-    @pytest.mark.parametrize(
-        "line", [[[0, 0, 0], [0, 0, 0]], {"START": [0, 0, 0], "END": [0, 0, 0]}]
-    )
+    @pytest.mark.parametrize("line", [[[0, 0, 0], [0, 0, 0]], {"START": [0, 0, 0], "END": [0, 0, 0]}])
     def test_schema_line_invalid(line_validator, line):
         with pytest.raises(jsonschema.exceptions.ValidationError):
             line_validator.validate(line)
@@ -226,16 +224,12 @@ def test_schema_line_invalid(line_validator, line):
     def test_schema_plane_valid(plane_validator, plane):
         plane_validator.validate(plane)
 
-    @pytest.mark.parametrize(
-        "plane", [[[0, 0, 0], [0, 0, 1]], {"POINT": [0, 0, 0], "NORMAL": [0, 0, 1]}]
-    )
+    @pytest.mark.parametrize("plane", [[[0, 0, 0], [0, 0, 1]], {"POINT": [0, 0, 0], "NORMAL": [0, 0, 1]}])
     def test_schema_plane_invalid(plane_validator, plane):
         with pytest.raises(jsonschema.exceptions.ValidationError):
             plane_validator.validate(plane)
 
-    @pytest.mark.parametrize(
-        "circle", [{"plane": {"point": [0, 0, 0], "normal": [0, 0, 1]}, "radius": 1.0}]
-    )
+    @pytest.mark.parametrize("circle", [{"plane": {"point": [0, 0, 0], "normal": [0, 0, 1]}, "radius": 1.0}])
     def test_schema_circle_valid(circle_validator, circle):
         circle_validator.validate(circle)
 
@@ -442,9 +436,7 @@ def test_schema_box_invalid(box_validator, box):
         with pytest.raises(jsonschema.exceptions.ValidationError):
             box_validator.validate(box)
 
-    @pytest.mark.parametrize(
-        "capsule", [{"line": {"start": [0, 0, 0], "end": [1, 0, 0]}, "radius": 1.0}]
-    )
+    @pytest.mark.parametrize("capsule", [{"line": {"start": [0, 0, 0], "end": [1, 0, 0]}, "radius": 1.0}])
     def test_schema_capsule_valid(capsule_validator, capsule):
         capsule_validator.validate(capsule)
 

tests/compas/datastructures/test_graph.py

@@ -35,10 +35,7 @@ def test_edgedata_io(graph):
     for index, (u, v) in enumerate(graph.edges()):
         graph.edge_attribute((u, v), "index", index)
     other = Graph.from_data(graph.data)
-    assert all(
-        other.edge_attribute(edge, "index") == index
-        for index, edge in enumerate(other.edges())
-    )
+    assert all(other.edge_attribute(edge, "index") == index for index, edge in enumerate(other.edges()))
 
 
 def test_data_schema(graph):

tests/compas/datastructures/test_halfedge.py

@@ -71,21 +71,15 @@ def test_edgedata_nondirectionality(mesh):
     mesh.update_default_edge_attributes({"index": 0})
     for index, (u, v) in enumerate(mesh.edges()):
         mesh.edge_attribute((u, v), "index", index)
-    assert all(
-        mesh.edge_attribute((u, v), "index") == mesh.edge_attribute((v, u), "index")
-        for u, v in mesh.edges()
-    )
+    assert all(mesh.edge_attribute((u, v), "index") == mesh.edge_attribute((v, u), "index") for u, v in mesh.edges())
 
 
 def test_edgedata_io(mesh):
     mesh.update_default_edge_attributes({"index": 0})
     for index, (u, v) in enumerate(mesh.edges()):
         mesh.edge_attribute((u, v), "index", index)
     other = HalfEdge.from_data(mesh.data)
-    assert all(
-        other.edge_attribute(edge, "index") == index
-        for index, edge in enumerate(other.edges())
-    )
+    assert all(other.edge_attribute(edge, "index") == index for index, edge in enumerate(other.edges()))
 
 
 def test_data_schema(mesh):

tests/compas/datastructures/test_halfface.py

@@ -84,9 +84,7 @@ def test_vertices_where_predicate():
     hf.add_vertex(0)
     hf.add_vertex(1, {"a": 5, "b": 10})
     hf.add_vertex(2, {"a": 15, "b": 20})
-    assert list(
-        hf.vertices_where_predicate(lambda v, attr: attr["b"] - attr["a"] == 5)
-    ) == [1, 2]
+    assert list(hf.vertices_where_predicate(lambda v, attr: attr["b"] - attr["a"] == 5)) == [1, 2]
 
 
 # ==============================================================================
@@ -109,9 +107,7 @@ def test_edges_where_predicate():
         hf.add_vertex(vkey)
     hf.add_halfface([0, 1, 2])
     hf.edge_attribute((0, 1), "a", 5)
-    assert list(hf.edges_where_predicate(lambda e, attr: attr["a"] - attr["b"] == 3))[
-        0
-    ] == (0, 1)
+    assert list(hf.edges_where_predicate(lambda e, attr: attr["a"] - attr["b"] == 3))[0] == (0, 1)
 
 
 # ==============================================================================
@@ -136,10 +132,7 @@ def test_faces_where_predicate():
     for i in range(3):
         hf.add_halfface([i, i + 1, i + 2])
     hf.face_attribute(1, "a", 5)
-    assert (
-        list(hf.faces_where_predicate(lambda e, attr: attr["a"] - attr["b"] == 3))[0]
-        == 1
-    )
+    assert list(hf.faces_where_predicate(lambda e, attr: attr["a"] - attr["b"] == 3))[0] == 1
 
 
 # ==============================================================================
@@ -178,7 +171,4 @@ def test_cells_where_predicate():
             ]
         )
     hf.cell_attribute(1, "a", 5)
-    assert (
-        list(hf.cells_where_predicate(lambda e, attr: attr["a"] - attr["b"] == 3))[0]
-        == 1
-    )
+    assert list(hf.cells_where_predicate(lambda e, attr: attr["a"] - attr["b"] == 3))[0] == 1

tests/compas/datastructures/test_mesh_subd.py

@@ -20,55 +20,41 @@ def test_quads_subdivide(mesh_quads):
     subd = mesh_quads.subdivide()
     assert subd.number_of_faces() == 4 * mesh_quads.number_of_faces()
     assert subd.number_of_vertices() == (
-        mesh_quads.number_of_vertices()
-        + mesh_quads.number_of_edges()
-        + mesh_quads.number_of_faces()
+        mesh_quads.number_of_vertices() + mesh_quads.number_of_edges() + mesh_quads.number_of_faces()
     )
 
 
 def test_tris_subdivide(mesh_tris):
     subd = mesh_tris.subdivide()
     assert subd.number_of_faces() == 3 * mesh_tris.number_of_faces()
     assert subd.number_of_vertices() == (
-        mesh_tris.number_of_vertices()
-        + mesh_tris.number_of_edges()
-        + mesh_tris.number_of_faces()
+        mesh_tris.number_of_vertices() + mesh_tris.number_of_edges() + mesh_tris.number_of_faces()
     )
 
 
 def test_quads_subdivide_tri(mesh_quads):
     subd = mesh_quads.subdivide(scheme="tri")
     assert subd.number_of_faces() == 4 * mesh_quads.number_of_faces()
-    assert (
-        subd.number_of_vertices()
-        == mesh_quads.number_of_vertices() + mesh_quads.number_of_faces()
-    )
+    assert subd.number_of_vertices() == mesh_quads.number_of_vertices() + mesh_quads.number_of_faces()
 
 
 def test_tris_subdivide_tri(mesh_tris):
     subd = mesh_tris.subdivide(scheme="tri")
     assert subd.number_of_faces() == 3 * mesh_tris.number_of_faces()
-    assert (
-        subd.number_of_vertices()
-        == mesh_tris.number_of_vertices() + mesh_tris.number_of_faces()
-    )
+    assert subd.number_of_vertices() == mesh_tris.number_of_vertices() + mesh_tris.number_of_faces()
 
 
 def test_quads_subdivide_quad(mesh_quads):
     subd = mesh_quads.subdivide(scheme="quad")
     assert subd.number_of_faces() == 4 * mesh_quads.number_of_faces()
     assert subd.number_of_vertices() == (
-        mesh_quads.number_of_vertices()
-        + mesh_quads.number_of_edges()
-        + mesh_quads.number_of_faces()
+        mesh_quads.number_of_vertices() + mesh_quads.number_of_edges() + mesh_quads.number_of_faces()
     )
 
 
 def test_tris_subdivide_quad(mesh_tris):
     subd = mesh_tris.subdivide(scheme="quad")
     assert subd.number_of_faces() == 3 * mesh_tris.number_of_faces()
     assert subd.number_of_vertices() == (
-        mesh_tris.number_of_vertices()
-        + mesh_tris.number_of_edges()
-        + mesh_tris.number_of_faces()
+        mesh_tris.number_of_vertices() + mesh_tris.number_of_edges() + mesh_tris.number_of_faces()
     )

tests/compas/geometry/test_core.py

@@ -197,14 +197,10 @@ def test_centroid_polyhedron(polyhedron, centroid):
 # ==============================================================================
 
 
-@pytest.mark.parametrize(
-    ("polyhedron", "volume"), [(Polyhedron.from_platonicsolid(6), None)]
-)
+@pytest.mark.parametrize(("polyhedron", "volume"), [(Polyhedron.from_platonicsolid(6), None)])
 def test_volume_polyhedron(polyhedron, volume):
     if volume is None:
-        L = length_vector(
-            subtract_vectors(polyhedron.vertices[0], polyhedron.vertices[1])
-        )
+        L = length_vector(subtract_vectors(polyhedron.vertices[0], polyhedron.vertices[1]))
         volume = L * L * L
     V = volume_polyhedron(polyhedron)
     assert close(V, volume)

tests/compas/geometry/test_distance.py

@@ -5,9 +5,7 @@
 from compas.geometry import closest_point_on_segment_xy
 
 
-@pytest.mark.parametrize(
-    "point,point_on_line", [[[0, 0, -10], [1, 1, 0]], [[5, 4, 80], [4.5, 4.5, 0]]]
-)
+@pytest.mark.parametrize("point,point_on_line", [[[0, 0, -10], [1, 1, 0]], [[5, 4, 80], [4.5, 4.5, 0]]])
 def test_closest_point_segment_xy(point, point_on_line):
     line = Line([1, 1, -15], [10, 10, 20])
     ponl = closest_point_on_segment_xy(Point(*point), line)

tests/compas/geometry/test_offset.py

@@ -79,9 +79,7 @@ def test_offset_polyline_equals_offset_line(polyline, distance, normal, tol):
         )
     ],
 )
-def test_variable_offset_on_colinear_polyline(
-    polyline, distance, normal, tol, output_polyline
-):
+def test_variable_offset_on_colinear_polyline(polyline, distance, normal, tol, output_polyline):
     output_polyline = [v for v in output_polyline]
     assert allclose(offset_polyline(polyline, distance, normal, tol), output_polyline)
 

tests/compas/geometry/test_polygon.py

@@ -10,12 +10,7 @@
 if not compas.IPY:
 
     def test_data():
-        p = Polygon(
-            [
-                Point(random.random(), random.random(), random.random())
-                for i in range(10)
-            ]
-        )
+        p = Polygon([Point(random.random(), random.random(), random.random()) for i in range(10)])
         assert p.data == p.validate_data()
         o = Polygon.from_data(p.data)
         assert p == o