class_docstr: Node in a tree that corresponds to previous interactions with
  a ``ConjectureData`` object according to some fixed test function.
  
  This is functionally a variant patricia trie.
  See https://en.wikipedia.org/wiki/Radix_tree for the general idea,
  but what this means in particular here is that we have a very deep
  but very lightly branching tree and rather than store this as a fully
  recursive structure we flatten prefixes and long branches into
  lists. This significantly compacts the storage requirements.
  
  A single ``TreeNode`` corresponds to a previously seen sequence
  of calls to ``ConjectureData`` which we have never seen branch,
  followed by a ``transition`` which describes what happens next.
docstr: Splits the tree so that it can incorporate
  a decision at the ``draw_bits`` call corresponding
  to position ``i``, or raises ``Flaky`` if that was
  meant to be a forced node.
docstr_tok: ["Splits","the","tree","so","that","it","can","incorporate","a","decision","at","the","``","draw_bits","``","call","corresponding","to","position","``","i","``",",","or","raises","``","Flaky","``","if","that","was","meant","to","be","a","forced","node","."]
code: def split_at(self, i):
      """Splits the tree so that it can incorporate
      a decision at the ``draw_bits`` call corresponding
      to position ``i``, or raises ``Flaky`` if that was
      meant to be a forced node."""
  
      if i in self.forced:
          inconsistent_generation()
  
      assert not self.is_exhausted
  
      key = self.values[i]
  
      child = TreeNode(
          bit_lengths=self.bit_lengths[i + 1 :],
          values=self.values[i + 1 :],
          transition=self.transition,
      )
      self.transition = Branch(
          bit_length=self.bit_lengths[i], children={key: child}
      )
      if self.__forced is not None:
          child.__forced = {j - i - 1 for j in self.__forced if j > i}
          self.__forced = {j for j in self.__forced if j < i}
      child.check_exhausted()
      del self.values[i:]
      del self.bit_lengths[i:]
      assert len(self.values) == len(self.bit_lengths) == i
  
imports: from __future__ import absolute_import, division, print_function
  import attr
  from hypothesis.errors import Flaky, HypothesisException
  from hypothesis.internal.compat import hbytes, int_to_bytes
  from hypothesis.internal.conjecture.data import ConjectureData, DataObserver, Status, StopTest, bits_to_bytes
  from hypothesis.internal.conjecture.junkdrawer import IntList
label_desc: Use image node_id 3 for calling the TreeNode obj's underlying member method code with example usage: obj.split_at(i) without return types