Organizing several similar classes with overlapping variables

[6hearts]

I am struggling for weeks now how to structarize a bunch of classes that have several similarities.
Perhaps the best analogy would be a class representing a graph, e.g. a bunch of nodes that may be connected with each other.
But I have several classes, where the nodes will have different meanings/behaviours, lets call the special nodes "vertices" and "points".
Every node/vertex/point will be a dictionary of lists (adjacent nodes).

The end user will access the nodes via Desciptors and cached properties (kinda what networkx does), but this is probably not important now.

So I have the base class that performs various operations on the nodes (e.g. can remove them)

class BaseGraph:

    def __init__(self, nodes):
        self._nodes = nodes

    def nodes(self):
        return NodeView(self._nodes)
   
    def remove_node(self, node):
        del self._nodes[node]
     ...

We would create an instance by

my_graph = BaseGraph({"a":["b","c"], "b":["a"], "c":["a"]})

(there are a bunch of methods and functions that modify and compute with the nodes).

But then I have several classes that will have BaseGraph as its parent, but the nodes will have somewhat different meaning, for instance, some can be modified one way, some the other way. Lets call different nodes "vertices" and "points". They classes also have different mathematical meanings, so it would not make sense to keep them as separate classes (kinda what networkx does, it has classes "Graph", "MultiGraph", "DirectedGraph",...)

So we have:

class VertexGraph(BaseGraph)
    def __init__(self, vertices):
        self._nodes = vertices

    def vertices(self):
        return NodeView(self._nodes)

class PointGraph(BaseGraph)
    def __init__(self, points):
        self._nodes = points

    def points(self):
        return NodeView(self._nodes)

    def do_something_with_point(self, point):
        ....

class VertexPointGraph(BaseGraph)
    def __init__(self, vertices, points):
        self._nodes = vertices | points
        self._points = points
        self._vertices = vertices

    def points(self):
        return NodeView(self._points)

    def vertices(self):
        return NodeView(self._vertices)

    def do_something_with_point(self, point):
        ....

I could just write several separate classes, but a lot of methods from BaseGraph performs the same operation on points or vertices, e.g. deletion (and the base class is several hundred lines long)

And a lot of functions func(graph) also do not care if the nodes are verties or graphs, but some do. So therefore it would make sense to store all points and vertices in _nodes, but then I have to keep track that _nodes, _points, and _vertices are always updated (if I change a point, I should also change the node, which is not optimal).

One idea, that would work, would be to keep track of the node type by a dictionary

    def __init__(self, vertices, points):
        self._nodes = vertices | points
        self.kind = {v:"Vertex" for v in vertices} | {p:"Point" for p in points}

But then there would be difficult e.g. to iterate over these, which I do often (e.g. iterate over points or iterate over vertices). Also, I would like to quickly know if a given node is a vertex or point.
Also, I would like the class to be extendible in the future, e.g. if I add a third kind of node.

So perhaps it is good the way it is, I just have to be careful to keep all nodes, vertices and points in sync when modifying and deleting them.

All ideas and thoughts are very welcome