some refactoring

connection.py

@@ -32,7 +32,7 @@ def CandidateConnections(
     return candidate_conn_nfo
 
 
-def ShortestPathTo(
+def ShortestPathFromToN(
     point: site_h,
     costs: array_t,
     candidate_points_fct: Callable,

main.py

@@ -100,7 +100,7 @@ candidate_conn_nfo = cn_.CandidateConnections(
 for ep_idx, soma, extension, end_point in candidate_conn_nfo:
     if extension.is_unconnected:
         print(f"    Soma.{soma.uid} <-?-> Ext.{extension.uid}({ep_idx})", end="")
-        path, length = cn_.ShortestPathTo(
+        path, length = cn_.ShortestPathFromToN(
             end_point,
             costs,
             soma.ContourPointsCloseTo,
@@ -142,7 +142,7 @@ while should_look_for_connections:
     for ep_idx, soma, extension, end_point in candidate_conn_nfo:
         if extension.is_unconnected:
             print(f"    Soma.{soma.uid} <-?-> Ext.{extension.uid}({ep_idx})", end="")
-            path, length = cn_.ShortestPathTo(
+            path, length = cn_.ShortestPathFromToN(
                 end_point,
                 costs,
                 soma.ExtensionPointsCloseTo,

soma.py

@@ -73,13 +73,7 @@ class soma_t(glial_cmp_t):
             if (np_.subtract(point, contour_point) ** 2).sum() <= max_distance
         )
 
-        if points.__len__() > 0:
-            points_as_picker = tuple(zip(*points))
-        else:
-            points = None
-            points_as_picker = None
-
-        return points, points_as_picker
+        return __PointsCloseTo__(points)
 
     def ExtensionPointsCloseTo(
         self, point: site_h, max_distance: float
@@ -96,54 +90,8 @@ class soma_t(glial_cmp_t):
                 for ext_point in ext_sites
                 if (np_.subtract(point, ext_point) ** 2).sum() <= max_distance
             )
-        points = tuple(points)
 
-        if points.__len__() > 0:
-            points_as_picker = tuple(zip(*points))
-        else:
-            points = None
-            points_as_picker = None
-
-        return points, points_as_picker
-
-    # def Extend(
-    #     self, extensions: Sequence[extension_t], dist_to_soma: array_t, costs: array_t
-    # ) -> None:
-    #     #
-    #     candidate_ext_nfo = []  # eps=end points
-    #     for extension in extensions:
-    #         new_candidates = extension.EndPointsForSoma(self.uid)
-    #         candidate_ext_nfo.extend(
-    #             (end_point, extension) for end_point in new_candidates
-    #         )
-    #     candidate_ext_nfo.sort(key=lambda elm: dist_to_soma[elm[0]])
-    #     unconnected_candidates = list(
-    #         filter(lambda elm: elm[1].soma_uid is None, candidate_ext_nfo)
-    #     )
-    #
-    #     should_look_for_connections = True
-    #     while should_look_for_connections:
-    #         som_ext_path_nfos = []
-    #         for ep_idx, (ext_end_point, extension) in enumerate(unconnected_candidates):
-    #             path, length = self.ShortestPathTo(
-    #                 extension.uid, ext_end_point, ep_idx, costs
-    #             )
-    #             if length <= max_weighted_dist:
-    #                 som_ext_path_nfos.append(
-    #                     som_ext_path_t(
-    #                         extension=extension, length=length, path=path, idx=ep_idx
-    #                     )
-    #                 )
-    #                 if path.__len__() == 2:
-    #                     break
-    #
-    #         if som_ext_path_nfos.__len__() > 0:
-    #             som_ext_path_nfos.sort(key=lambda nfo: nfo.length)
-    #             shorest_path = som_ext_path_nfos[0]
-    #             self.ExtendWith(shorest_path.extension, shorest_path.path, costs)
-    #             del unconnected_candidates[shorest_path.idx]
-    #         else:
-    #             should_look_for_connections = False
+        return __PointsCloseTo__(tuple(points))
 
     def BackReferenceSoma(self, glial_cmp: glial_cmp_t) -> None:
         #
@@ -252,6 +200,19 @@ class soma_t(glial_cmp_t):
         return result
 
 
+def __PointsCloseTo__(
+    points: Tuple[site_h, ...]
+) -> Tuple[Optional[Tuple[site_h, ...]], Optional[py_array_picker_h]]:
+    #
+    if points.__len__() > 0:
+        points_as_picker = tuple(zip(*points))
+    else:
+        points = None
+        points_as_picker = None
+
+    return points, points_as_picker
+
+
 def NormalizedImage(image: array_t) -> array_t:
     #
     nonextreme_values = image[np_.logical_and(image > 0.0, image < image.max())]