Return to Answer

class Node:
    def __init__(self, name):
        self.connections = set()
        self.name = name
        self.total_cost = -1
        self.last_connection = None
        self.visited = False

    def __str__(self):
        return f"Name: {self.name}, total cost: {self.total_cost}, connections: {[(node.name, cost) for node, cost in self.connections]}"

    __repr__ = __str__


def parse_graph(lines):
    graph = {}
    for line in lines:
        if line.startswith("node "):
            name = line[5:]
            # Get the node if it already exists, otherwise create a new node
            node = graph.setdefault(name, Node(name))
        elif line.startswith(("\t", " "*4)):  # some editors might replace \t with 4 spaces, careful!
            name2, cost = line.strip().split(",")
            # Get the other node if it already exists, otherwise create a new node
            node2 = graph.setdefault(name2, Node(name2))
            # add connections manually, no need to iterate over all existing connections
            node.connections.add((node2, int(cost)))  # int can deal with whitespace
        else:
            raise ValueError(f"Cannot parse line: {line}")
    return graph

The crucial part here is adding a node when you see it the first time (even just as a target of a connection) and getting the same node back again when it already exists. Currently there is no sanity check that all nodes that are referenced as targets of connections are actually defined, you might want to add that.

class Node:
    def __init__(self, name):
        self.connections = set()
        self.name = name
        self.total_cost = -1
        self.last_connection = None
        self.visited = False

    def __str__(self):
        return f"Name: {self.name}, total cost: {self.total_cost}, connections: {[(node.name, cost) for node, cost in self.connections]}"

    __repr__ = __str__


def parse_graph(lines):
    graph = {}
    for line in lines:
        if line.startswith("node "):
            name = line[5:]
            # Get the node if it already exists, otherwise create a new node
            node = graph.setdefault(name, Node(name))
        elif line.startswith(("\t", " "*4)):  # some editors might replace \t with 4 spaces, careful!
            name2, cost = line.strip().split(",")
            # Get the other node if it already exists, otherwise create a new node
            node2 = graph.setdefault(name2, Node(name2))
            # add connection manually, no need to iterate over all existing connections
            # reverse connection added in definition of node2
            node.connections.add((node2, int(cost)))  # int can deal with whitespace
        else:
            raise ValueError(f"Cannot parse line: {line}")
    return graph

The crucial part here is adding a node when you see it the first time (even just as a target of a connection) and getting the same node back again when it already exists. For this I used dict.setdefault, which is functionally equivalent to:

if name not in graph:
    graph[name] = Node(name)
node = graph[name]

Currently there is no sanity check that all nodes that are referenced as targets of connections are actually defined, you might want to add that.

class Node:
    def __init__(self, name):
        self.connections = set()
        self.name = name
        self.total_cost = -1
        self.last_connection = None
        self.visited = False

    def __str__(self):
        return f"Name: {self.name}, total cost: {self.total_cost}, connections: {[(node.name, cost) for node, cost in self.connections]}"

    __repr__ = __str__


def parse_graph(lines):
    graph = {}
    for line in lines:
        if line.startswith("node "):
            name = line[5:]
            # Get the node if it already exists, otherwise create a new node
            node = graph[name] = graph.get(name, Node(name))
        elif line.startswith(("\t", " "*4)):  # some editors might replace \t with 4 spaces, careful!
            name2, cost = line.strip().split(",")
            cost = int(cost)  # int can deal with whitespace
            # Get the other node if it already exists, otherwise create a new node
            node2 = graph[name2] = graph.get(name2, Node(name2))
            # add connections manually, no need to iterate over all existing connections
            node.connections.add((node2, cost))
            node2.connections.add((node, cost))
        else:
            raise ValueError(f"Cannot parse line: {line}")
    return graph

def main():
    with open("graph.txt") as file:
        graph = parse_graph(file)

    start_node = graph["S"]
    end_node = graph["E"]

    d = Dijkstra(graph, start_node, end_node)
    path = d.calculate_shortest_path()
    for i in path:
        print(i.name)

if __name__ == "__main__":
    main()

class Node:
    def __init__(self, name):
        self.connections = set()
        self.name = name
        self.total_cost = -1
        self.last_connection = None
        self.visited = False

    def __str__(self):
        return f"Name: {self.name}, total cost: {self.total_cost}, connections: {[(node.name, cost) for node, cost in self.connections]}"

    __repr__ = __str__


def parse_graph(lines):
    graph = {}
    for line in lines:
        if line.startswith("node "):
            name = line[5:]
            # Get the node if it already exists, otherwise create a new node
            node = graph.setdefault(name, Node(name))
        elif line.startswith(("\t", " "*4)):  # some editors might replace \t with 4 spaces, careful!
            name2, cost = line.strip().split(",")
            # Get the other node if it already exists, otherwise create a new node
            node2 = graph.setdefault(name2, Node(name2))
            # add connections manually, no need to iterate over all existing connections
            node.connections.add((node2, int(cost)))  # int can deal with whitespace
        else:
            raise ValueError(f"Cannot parse line: {line}")
    return graph

def main():
    with open("graph.txt") as file:
        graph = parse_graph(file)

    start_node = graph["S"]
    end_node = graph["E"]

    d = Dijkstra(graph, start_node, end_node)
    path = d.calculate_shortest_path()
    for i in path:
        print(i.name)

if __name__ == "__main__":
    main()

If you have control over the file format, you can take this assuming a node exists if it is mentioned to an extreme to cut down on the number of lines needed. Your graph.txt could then be (assuming all connections are still bi-directional and cost symmetric):

A, D, 4
A, B, 3
A, S, 7
B, S, 2
B, D, 4
B, H, 1
C, S, 3
C, L, 2
D, F, 5
E, G, 2
E, K, 5
F, H, 3
G, H, 2
I, L, 4
I, K, 4
I, J, 6
J, L, 4
J, K, 4

For your example file this returns this graph structure:

It also uses the fact that Node.connections is a set, so adding an already exisitng conenction does not hurt, because the tuple (Node, cost) is hashable (using the id of `Node).

For your example file this returns this graph structure: