code: def _see_node(self, node_id, fringe, dist, w_wait_in=0):
          
  
          # Namespace shortcuts.
          seen, dists = self.seen, self.dist
  
          wait_in = self.nodes[node_id]['wait_inputs']  # Wait inputs flag.
  
          self._update_meeting(node_id, dist)  # Update view distance.
  
          # Check if inputs are satisfied.
          if self.check_wait_in(wait_in, node_id):
              pass  # Pass the node
  
          elif node_id in dists:  # The node w already estimated.
              if dist < dists[node_id]:  # Error for negative paths.
                  raise DispatcherError('Contradictory paths found: '
                                        'negative weights?', sol=self)
          elif node_id not in seen or dist < seen[node_id]:  # Check min dist.
              seen[node_id] = dist  # Update dist.
  
              index = self.nodes[node_id]['index']  # Node index.
  
              # Virtual distance.
              vd = (w_wait_in + int(wait_in), node_id, self.index + index)
  
              # Add to heapq.
              heapq.heappush(fringe, (dist, vd, (node_id, self)))
  
              return True  # The node is visible.
          return False
docs: See a node, updating seen and fringe.
  
          :param node_id:
              Node id to see.
          :type node_id: str
  
          :param fringe:
              Heapq of closest available nodes.
          :type fringe: list[(float | int, bool, (str, Dispatcher)]
  
          :param dist:
              Distance from the starting node.
          :type dist: float, int
  
          :param w_wait_in:
              Additional weight for sorting correctly the nodes in the fringe.
          :type w_wait_in: int, float
  
          :return:
              True if the node is visible, otherwise False.
          :rtype: bool