chore(lint): fix linting issues

Author: BrianLusina

datastructures/graphs/edge/edge.py

@@ -6,6 +6,7 @@
 
 T = TypeVar("T")
 
+
 class Edge(ABC, Generic[T]):
     """
     Edge representation of an abstract Edge in a Graph

datastructures/graphs/edge/edge_directed.py

@@ -5,15 +5,21 @@
 
 T = TypeVar("T")
 
+
 class DirectedEdge(Edge, Generic[T]):
     """
     Directed Edge representation of a directed Edge in a Graph where the edge connects two vertices which has a source
     vertex and a destination vertex.
     """
 
-    def __init__(self, source: Any, destination: Any, weight: Optional[Union[int, float]] = None,
-                 properties: Optional[Dict[str, Any]] = None,
-                 identifier: AnyStr = uuid4()):
+    def __init__(
+        self,
+        source: Any,
+        destination: Any,
+        weight: Optional[Union[int, float]] = None,
+        properties: Optional[Dict[str, Any]] = None,
+        identifier: AnyStr = uuid4(),
+    ):
         super().__init__(weight, properties, identifier)
         self.source = source
         self.destination = destination

datastructures/graphs/edge/edge_hyper.py

@@ -5,14 +5,19 @@
 
 T = TypeVar("T")
 
+
 class HyperEdge(Edge, Generic[T]):
     """
     HyperEdge representation of a hyper-edge in a Graph where the edge connects to the multiple vertices
     """
 
-    def __init__(self, nodes: List[Any], weight: Optional[Union[int, float]] = None,
-                 properties: Optional[Dict[str, Any]] = None,
-                 identifier: AnyStr = uuid4()):
+    def __init__(
+        self,
+        nodes: List[Any],
+        weight: Optional[Union[int, float]] = None,
+        properties: Optional[Dict[str, Any]] = None,
+        identifier: AnyStr = uuid4(),
+    ):
         super().__init__(weight, properties, identifier)
         self.nodes = nodes
 

datastructures/graphs/edge/edge_self.py

@@ -5,14 +5,19 @@
 
 T = TypeVar("T")
 
+
 class SelfEdge(Edge, Generic[T]):
     """
     Self-Edge representation of a self-edge in a Graph where the edge connects to the same vertex
     """
 
-    def __init__(self, node: Any, weight: Optional[Union[int, float]] = None,
-                 properties: Optional[Dict[str, Any]] = None,
-                 identifier: AnyStr = uuid4()):
+    def __init__(
+        self,
+        node: Any,
+        weight: Optional[Union[int, float]] = None,
+        properties: Optional[Dict[str, Any]] = None,
+        identifier: AnyStr = uuid4(),
+    ):
         super().__init__(weight, properties, identifier)
         self.node_one = node
 

datastructures/graphs/edge/edge_undirected.py

@@ -5,20 +5,28 @@
 
 T = TypeVar("T")
 
+
 class UndirectedEdge(Edge, Generic[T]):
     """
     Undirected Edge representation of an undirected Edge in a Graph where the edge connects two vertices.
     """
 
-    def __init__(self, node_one: Any, node_two: Any, weight: Optional[Union[int, float]] = None,
-                 properties: Optional[Dict[str, Any]] = None,
-                 identifier: AnyStr = uuid4()):
+    def __init__(
+        self,
+        node_one: Any,
+        node_two: Any,
+        weight: Optional[Union[int, float]] = None,
+        properties: Optional[Dict[str, Any]] = None,
+        identifier: AnyStr = uuid4(),
+    ):
         super().__init__(weight, properties, identifier)
         self.node_one = node_one
         self.node_two = node_two
 
     def __str__(self):
-        return f"{super().__str__()}, NodeOne: {self.node_one}, NodeTwo: {self.node_two}"
+        return (
+            f"{super().__str__()}, NodeOne: {self.node_one}, NodeTwo: {self.node_two}"
+        )
 
     def edge_type(self) -> EdgeType:
         return EdgeType.Undirected

datastructures/graphs/test_vertex.py

@@ -12,5 +12,5 @@ def test_1(self):
         self.assertEqual(True, False)  # add assertion here
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     unittest.main()

datastructures/graphs/undirected/test_utils.py

@@ -6,18 +6,32 @@
 
 class ClosestNodeToPathInTreeTestCase(unittest.TestCase):
 
-    @parameterized.expand([
-        (3, [[0,1],[1,2]], [[0,2,1]], [1]),
-        (4, [[0,1],[1,2],[1,3]], [[2,3,0]], [1]),
-        (6, [[0,1],[0,2],[0,3],[0,4],[0,5]], [[1,5,2],[2,3,4]], [0,0]),
-        (7, [[0,1],[0,2],[0,3],[1,4],[2,5],[2,6]], [[5,3,4],[5,3,6]], [0,2]),
-        (3, [[0,1],[1,2]], [[0,1,2]], [1]),
-        (3, [[0,1],[1,2]], [[0,0,0]], [0]),
-    ])
-    def test_closest_node(self, n: int, edges: List[List[int]], query: List[List[int]], expected: int):
+    @parameterized.expand(
+        [
+            (3, [[0, 1], [1, 2]], [[0, 2, 1]], [1]),
+            (4, [[0, 1], [1, 2], [1, 3]], [[2, 3, 0]], [1]),
+            (
+                6,
+                [[0, 1], [0, 2], [0, 3], [0, 4], [0, 5]],
+                [[1, 5, 2], [2, 3, 4]],
+                [0, 0],
+            ),
+            (
+                7,
+                [[0, 1], [0, 2], [0, 3], [1, 4], [2, 5], [2, 6]],
+                [[5, 3, 4], [5, 3, 6]],
+                [0, 2],
+            ),
+            (3, [[0, 1], [1, 2]], [[0, 1, 2]], [1]),
+            (3, [[0, 1], [1, 2]], [[0, 0, 0]], [0]),
+        ]
+    )
+    def test_closest_node(
+        self, n: int, edges: List[List[int]], query: List[List[int]], expected: int
+    ):
         actual = closest_node(n, edges, query)
         self.assertEqual(expected, actual)
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     unittest.main()

datastructures/graphs/undirected/utils.py

@@ -79,7 +79,7 @@ def find_path(start: int, end: int) -> List[int]:
 
         # Find the node on the path with minimum distance to target
         # If there's a tie, we want the one with the smallest index
-        min_distance = float('inf')
+        min_distance = float("inf")
         closest = -1
 
         for node in found_path:

datastructures/graphs/vertex.py

@@ -27,7 +27,7 @@ def __init__(
         self.incoming_edges = incoming_edges
         self.outgoing_edges = outgoing_edges
         self.edges = self.incoming_edges.union(self.outgoing_edges)
-        self.adjacent_vertices: Dict[str, 'Vertex'] = {}
+        self.adjacent_vertices: Dict[str, "Vertex"] = {}
         self.properties = properties
 
     def __str__(self):
@@ -125,4 +125,3 @@ def out_degree(self) -> int:
                 out_degrees += 1
 
         return out_degrees
-