docs: def find_connection_point(node, node_shp, graph, proj, conn_objects_min_stack, conn_dist_ring_mod, debug):
      """ Goes through the possible target connection objects in `conn_objects_min_stack` (from nearest to most far
          object) and tries to connect `node` to one of them.
  
      Function searches from nearest to most far object.
      
      Args
      ----
      node: LVLoadAreaCentreDing0, i.e.
          Origin node - Ding0 graph object (e.g. LVLoadAreaCentreDing0)
      node_shp: :shapely:`Shapely Point object<points>`
          Shapely Point object of node
      graph: :networkx:`NetworkX Graph Obj< >`
          NetworkX graph object with nodes
      proj: :pyproj:`pyproj Proj object< >`
          equidistant CRS to conformal CRS (e.g. ETRS -> WGS84)
      conn_objects_min_stack: list
          List of connection objects. 
          
          Each object is represented by dict with Ding0 object, shapely object,
          and distance to node, sorted ascending by distance.
      conn_dist_ring_mod: type
          Max. distance when nodes are included into route instead of creating a 
          new line.
      debug: bool
          If True, information is printed during process
  
      See Also
      --------
      ding0.grid.mv_grid.mv_connect : for details on the `conn_dist_ring_mod` parameter.
      """
  
      node_connected = False
  
      # go through the stack (from nearest to most far connection target object)
      for dist_min_obj in conn_objects_min_stack:
  
          nodes_are_members_of_ring = False
  
          # target object is branch
          if isinstance(dist_min_obj['shp'], LineString):
              # rename for readability
              node1 = dist_min_obj['obj']['adj_nodes'][0]
              node2 = dist_min_obj['obj']['adj_nodes'][1]
  
              lv_load_area_group = get_lv_load_area_group_from_node_pair(node1, node2)
  
              # check if target branch belongs to a main ring
              nodes_are_members_of_ring = any(node1 in ring and node2 in ring for ring in node.grid.rings_nodes())
              branch_ring = dist_min_obj['obj']['branch'].ring
  
          # target object is node
          else:
              if isinstance(dist_min_obj['obj'], MVCableDistributorDing0):
                  lv_load_area_group = dist_min_obj['obj'].lv_load_area_group
              else:
                  lv_load_area_group = dist_min_obj['obj'].lv_load_area.lv_load_area_group
  
          # target object doesn't belong to a satellite string (is not a member of a Load Area group)
          if not lv_load_area_group:
  
              # connect node
              target_obj_result = connect_node(node,
                                               node_shp,
                                               node.lv_load_area.mv_grid_district.mv_grid,
                                               dist_min_obj,
                                               proj,
                                               graph,
                                               conn_dist_ring_mod,
                                               debug)
  
              # if node was connected via branch (target line not re-routed and not member of aggregated load area):
              # create new LV load_area group for current node
              if (target_obj_result is not None) and (target_obj_result != 're-routed'):
                  lv_load_area_group = LoadAreaGroupDing0(mv_grid_district=node.lv_load_area.mv_grid_district,
                                                          root_node=target_obj_result)
                  lv_load_area_group.add_lv_load_area(lv_load_area=node.lv_load_area)
                  node.lv_load_area.lv_load_area_group = lv_load_area_group
                  node.lv_load_area.mv_grid_district.add_lv_load_area_group(lv_load_area_group)
  
                  if debug:
                      logger.debug('New LV load_area group {} created!'.format(
                          lv_load_area_group))
  
                  # node connected, stop connection for current node
                  node_connected = True
                  break
  
              # node was inserted into line (target line was re-routed)
              elif target_obj_result == 're-routed':
  
                  # if main ring was re-routed to include node => node is not a satellite anymore
                  if nodes_are_members_of_ring:
                      node.lv_load_area.is_satellite = False
                      node.lv_load_area.ring = branch_ring
  
                  # node connected, stop connection for current node
                  node_connected = True
                  break
  
          # target object is member of a Load Area group
          else:
  
              # connect node
              target_obj_result = connect_node(node,
                                               node_shp,
                                               node.lv_load_area.mv_grid_district.mv_grid,
                                               dist_min_obj,
                                               proj,
                                               graph,
                                               conn_dist_ring_mod,
                                               debug)
  
              # if node was connected via branch (target line not re-routed and not member of aggregated load area):
              # create new LV load_area group for current node
              if (target_obj_result is not None) and (target_obj_result != 're-routed'):
                  # node can join LV load_area group
                  if lv_load_area_group.can_add_lv_load_area(node=node):
  
                      # add node to LV load_area group
                      lv_load_area_group.add_lv_load_area(lv_load_area=node.lv_load_area)
                      node.lv_load_area.lv_load_area_group = lv_load_area_group
  
                      if isinstance(target_obj_result, MVCableDistributorDing0):
                          lv_load_area_group.add_lv_load_area(lv_load_area=target_obj_result)
                          target_obj_result.lv_load_area_group = lv_load_area_group
  
                      if debug:
                          logger.debug('LV load_area group {} joined!'.format(
                              lv_load_area_group))
  
                      # node connected, stop connection for current node
                      node_connected = True
                      break
  
                  # cannot join LV load_area group
                  else:
                      if debug:
                          logger.debug('Node {0} could not be added to '
                                       'load_area group {1}'.format(
                              node, lv_load_area_group))
  
                      # rollback changes in graph
                      disconnect_node(node, target_obj_result, graph, debug)
  
                      # continue with next possible connection point
                      continue
  
              # node was inserted into line (target line was re-routed)
              elif target_obj_result == 're-routed':
                  # add node to LV load_area group
                  lv_load_area_group.add_lv_load_area(lv_load_area=node.lv_load_area)
                  node.lv_load_area.lv_load_area_group = lv_load_area_group
  
                  # if main ring was re-routed to include node => node is not a satellite anymore
                  if nodes_are_members_of_ring:
                      node.lv_load_area.is_satellite = False
                      node.lv_load_area.ring = branch_ring
  
                  # node inserted into existing route, stop connection for current node
                  node_connected = True
                  break
  
              # else: node could not be connected because target object belongs to load area of aggregated type
  
      if not node_connected and debug:
          logger.debug(
              'Node {} could not be connected, try to increase the parameter '
              '`load_area_sat_buffer_radius` in config file `config_calc.cfg` '
              'to gain more possible connection points.'.format(node))