code: def _do_weak_search(self, obj, recursive):
          
          obj = parse_anything(obj)
          if not obj or obj not in self:
              raise ValueError(obj)
          results = []
          contexts = [self]
          while contexts:
              context = contexts.pop()
              i = len(context.nodes) - 1
              while i >= 0:
                  node = context.get(i)
                  if obj.get(-1) == node:
                      for j in range(-len(obj.nodes), -1):
                          if obj.get(j) != context.get(i + j + 1):
                              break
                      else:
                          i -= len(obj.nodes) - 1
                          index = slice(i, i + len(obj.nodes))
                          results.append((True, context, index))
                  elif recursive and obj in node:
                      contexts.extend(node.__children__())
                  i -= 1
          if not results:
              if not recursive:
                  raise ValueError(obj)
              results.append((False, self, slice(0, len(self.nodes))))
          return results
docs: Search for an element that looks like *obj* within the node list.
  
          This follows the same rules as :meth:`_do_strong_search` with some
          differences. *obj* is treated as a string that might represent any
          :class:`.Node`, :class:`.Wikicode`, or combination of the two present
          in the node list. Thus, matching is weak (using string comparisons)
          rather than strong (using ``is``). Because multiple nodes can match
          *obj*, the result is a list of tuples instead of just one (however,
          :exc:`ValueError` is still raised if nothing is found). Individual
          matches will never overlap.
  
          The tuples contain a new first element, *exact*, which is ``True`` if
          we were able to match *obj* exactly to one or more adjacent nodes, or
          ``False`` if we found *obj* inside a node or incompletely spanning
          multiple nodes.