docs: def get_turn_delta(self, branch=None, turn=None, tick_from=0, tick_to=None):
          """Get a dictionary describing changes made on a given turn.
  
          If ``tick_to`` is not supplied, report all changes after ``tick_from``
          (default 0).
  
          The keys are graph names. Their values are dictionaries of the graphs'
          attributes' new values, with ``None`` for deleted keys. Also in those graph
          dictionaries are special keys 'node_val' and 'edge_val' describing changes
          to node and edge attributes, and 'nodes' and 'edges' full of booleans
          indicating whether a node or edge exists.
  
          :arg branch: A branch of history; defaults to the current branch
          :arg turn: The turn in the branch; defaults to the current turn
          :arg tick_from: Starting tick; defaults to 0
  
          """
          branch = branch or self.branch
          turn = turn or self.turn
          tick_to = tick_to or self.tick
          delta = {}
          if tick_from < tick_to:
              gvbranches = self._graph_val_cache.settings
              nbranches = self._nodes_cache.settings
              nvbranches = self._node_val_cache.settings
              ebranches = self._edges_cache.settings
              evbranches = self._edge_val_cache.settings
          else:
              gvbranches = self._graph_val_cache.presettings
              nbranches = self._nodes_cache.presettings
              nvbranches = self._node_val_cache.presettings
              ebranches = self._edges_cache.presettings
              evbranches = self._edge_val_cache.presettings
  
          if branch in gvbranches and turn in gvbranches[branch]:
              for graph, key, value in gvbranches[branch][turn][tick_from:tick_to]:
                  if graph in delta:
                      delta[graph][key] = value
                  else:
                      delta[graph] = {key: value}
  
          if branch in nbranches and turn in nbranches[branch]:
              for graph, node, exists in nbranches[branch][turn][tick_from:tick_to]:
                  delta.setdefault(graph, {}).setdefault('nodes', {})[node] = bool(exists)
  
          if branch in nvbranches and turn in nvbranches[branch]:
              for graph, node, key, value in nvbranches[branch][turn][tick_from:tick_to]:
                  if (
                      graph in delta and 'nodes' in delta[graph] and
                      node in delta[graph]['nodes'] and not delta[graph]['nodes'][node]
                  ):
                      continue
                  nodevd = delta.setdefault(graph, {}).setdefault('node_val', {})
                  if node in nodevd:
                      nodevd[node][key] = value
                  else:
                      nodevd[node] = {key: value}
  
          graph_objs = self._graph_objs
          if branch in ebranches and turn in ebranches[branch]:
              for graph, orig, dest, idx, exists in ebranches[branch][turn][tick_from:tick_to]:
                  if graph_objs[graph].is_multigraph():
                      if (
                          graph in delta and 'edges' in delta[graph] and
                          orig in delta[graph]['edges'] and dest in delta[graph]['edges'][orig]
                          and idx in delta[graph]['edges'][orig][dest]
                          and not delta[graph]['edges'][orig][dest][idx]
                      ):
                          continue
                      delta.setdefault(graph, {}).setdefault('edges', {})\
                          .setdefault(orig, {}).setdefault(dest, {})[idx] = bool(exists)
                  else:
                      if (
                          graph in delta and 'edges' in delta[graph] and
                          orig in delta[graph]['edges'] and dest in delta[graph]['edges'][orig]
                          and not delta[graph]['edges'][orig][dest]
                      ):
                          continue
                      delta.setdefault(graph, {}).setdefault('edges', {})\
                          .setdefault(orig, {})[dest] = bool(exists)
  
          if branch in evbranches and turn in evbranches[branch]:
              for graph, orig, dest, idx, key, value in evbranches[branch][turn][tick_from:tick_to]:
                  edgevd = delta.setdefault(graph, {}).setdefault('edge_val', {})\
                      .setdefault(orig, {}).setdefault(dest, {})
                  if graph_objs[graph].is_multigraph():
                      if idx in edgevd:
                          edgevd[idx][key] = value
                      else:
                          edgevd[idx] = {key: value}
                  else:
                      edgevd[key] = value
  
          return delta