Find the nearest neighbor of a nearest neighbor of a nearest neighbor of...

We can use scipy to do something very similar to the NeighborhoodFinder, making it possible to "customize" the behavior and loop over the list of nodes while eliminating previous matches. Here's the code from the PythonCaller:

from scipy.spatial import distanceimport fmeobjectsdef get_closest_node_index(node, nodes):    return distance.cdist([node], nodes).argmin()class CreatePointTopology():        def __init__(self):        self.nodes = []            def input(self, feature):        node = feature.getCoordinate(0)        self.nodes.append(node)            def close(self):        current_node = self.nodes.pop(0)        while len(self.nodes) >= 1:            output = fmeobjects.FMEFeature()            idx = get_closest_node_index(current_node, self.nodes)            output.addCoordinate(current_node[0], current_node[1])            output.addCoordinate(self.nodes[idx][0], self.nodes[idx][1])            current_node = self.nodes.pop(idx)            self.pyoutput(output)

The main assumptions are that all points are 2D and that the first point will be the starting point. You will want to make sure that you have at least two input points.

I've also attached a test workspace (FME 2019.0.2.0) to show the code in context: createpointtopology.fmwt

Sure, you can simply add the necessary attributes as dictionary in self.nodes. Example line 14:

my_attr1 = feature.getAttribute('my_attr1')
node_dict = {'node': node, 'my_attr1': my_attr1}
self.nodes.append(node_dict)

Then change the rest of the code accordingly.

Try using the following code in the PythonCaller to retain the point attributes:

from scipy.spatial import distance
import fmeobjects

def get_closest_node_index(node, nodes):
    return distance.cdist([node], nodes).argmin()

class CreatePointTopology():
    
    def __init__(self):
        self.nodes = []
        self.attribs = []
        
    def input(self, feature):
        node = feature.getCoordinate(0)
        self.nodes.append(node)
        attribs = {k:feature.getAttribute(k) for k in feature.getAllAttributeNames() if not k.startswith('fme_')}
        self.attribs.append(attribs)
        
    def close(self):
        from_node = self.nodes.pop(0)
        from_attribs = self.attribs.pop(0)
        while len(self.nodes) >= 1:
            output = fmeobjects.FMEFeature()
            to_node_idx = get_closest_node_index(from_node, self.nodes)
            to_node = self.nodes[to_node_idx]
            to_attribs = self.attribs[to_node_idx]
            for f in from_attribs.keys():
                output.setAttribute('from_'+f, from_attribs[f])
            for t in to_attribs.keys():
                output.setAttribute('to_'+t, to_attribs[t])
            output.addCoordinate(from_node[0], from_node[1])
            output.addCoordinate(to_node[0], to_node[1])
            from_node = self.nodes.pop(to_node_idx)
            from_attribs = self.attribs.pop(to_node_idx)
            self.pyoutput(output)            

Each output segment will retain the point attributes prefixed with either "from_" or "to_", e.g. a segment that goes from a point with attribute X=1 to a point with attribute X=2, will result in a segment with from_X=1 and to_X=2.

If you still want/need to use the LineCombiner, make sure to enable "Generate List" to avoid loosing the output attributes.