nodes: 0, module; 1, function_definition; 2, function_name:intersects; 3, parameters; 4, block; 5, identifier:self; 6, identifier:key; 7, default_parameter; 8, default_parameter; 9, default_parameter; 10, default_parameter; 11, expression_statement; 12, expression_statement; 13, if_statement; 14, expression_statement; 15, expression_statement; 16, return_statement; 17, identifier:include_self; 18, False; 19, identifier:exclusive; 20, False; 21, identifier:biggest_first; 22, True; 23, identifier:only; 24, None; 25, comment:"""Get all locations that intersect this location.
  
          Note that sorting is done by first by number of faces intersecting ``key``; the total number of faces in the intersected region is only used to break sorting ties.
  
          If the ``resolved_row`` context manager is not used, ``RoW`` doesn't have a spatial definition, and therefore nothing intersects it. ``.intersects("RoW")`` returns a list with with ``RoW`` or nothing.
  
          """; 26, assignment; 27, boolean_operator; 28, block; 29, assignment; 30, assignment; 31, call; 32, identifier:possibles; 33, conditional_expression:self.topology if only is None else {k: self[k] for k in only}; 34, comparison_operator:key == 'RoW'; 35, comparison_operator:'RoW' not in self; 36, return_statement; 37, identifier:faces; 38, subscript; 39, identifier:lst; 40, list_comprehension; 41, attribute; 42, argument_list; 43, attribute; 44, comparison_operator:only is None; 45, dictionary_comprehension; 46, identifier:key; 47, string; 48, string; 49, identifier:self; 50, conditional_expression:['RoW'] if 'RoW' in possibles else []; 51, identifier:self; 52, identifier:key; 53, tuple; 54, for_in_clause; 55, if_clause; 56, identifier:self; 57, identifier:_finish_filter; 58, identifier:lst; 59, identifier:key; 60, identifier:include_self; 61, identifier:exclusive; 62, identifier:biggest_first; 63, identifier:self; 64, identifier:topology; 65, identifier:only; 66, None; 67, pair; 68, for_in_clause; 69, string_content:RoW; 70, string_content:RoW; 71, list; 72, comparison_operator:'RoW' in possibles; 73, list; 74, identifier:k; 75, tuple; 76, pattern_list; 77, call; 78, parenthesized_expression; 79, identifier:k; 80, subscript; 81, identifier:k; 82, identifier:only; 83, string; 84, string; 85, identifier:possibles; 86, call; 87, call; 88, identifier:k; 89, identifier:v; 90, attribute; 91, argument_list; 92, call; 93, identifier:self; 94, identifier:k; 95, string_content:RoW; 96, string_content:RoW; 97, identifier:len; 98, argument_list; 99, identifier:len; 100, argument_list; 101, identifier:possibles; 102, identifier:items; 103, attribute; 104, argument_list; 105, call; 106, identifier:v; 107, identifier:faces; 108, identifier:intersection; 109, identifier:v; 110, attribute; 111, argument_list; 112, identifier:v; 113, identifier:intersection; 114, identifier:faces
code: def intersects(self, key, include_self=False, exclusive=False, biggest_first=True, only=None):
          """Get all locations that intersect this location.
  
          Note that sorting is done by first by number of faces intersecting ``key``; the total number of faces in the intersected region is only used to break sorting ties.
  
          If the ``resolved_row`` context manager is not used, ``RoW`` doesn't have a spatial definition, and therefore nothing intersects it. ``.intersects("RoW")`` returns a list with with ``RoW`` or nothing.
  
          """
          possibles = self.topology if only is None else {k: self[k] for k in only}
  
          if key == 'RoW' and 'RoW' not in self:
              return ['RoW'] if 'RoW' in possibles else []
  
          faces = self[key]
          lst = [
              (k, (len(v.intersection(faces)), len(v)))
              for k, v in possibles.items()
              if (faces.intersection(v))
          ]
          return self._finish_filter(lst, key, include_self, exclusive, biggest_first)