code: def execute_until_in_scope(
      expr, scope, aggcontext=None, clients=None, post_execute_=None, **kwargs
  ):
      
      # these should never be None
      assert aggcontext is not None, 'aggcontext is None'
      assert clients is not None, 'clients is None'
      assert post_execute_ is not None, 'post_execute_ is None'
  
      # base case: our op has been computed (or is a leaf data node), so
      # return the corresponding value
      op = expr.op()
      if op in scope:
          return scope[op]
  
      new_scope = execute_bottom_up(
          expr,
          scope,
          aggcontext=aggcontext,
          post_execute_=post_execute_,
          clients=clients,
          **kwargs,
      )
      new_scope = toolz.merge(
          new_scope, pre_execute(op, *clients, scope=scope, **kwargs)
      )
      return execute_until_in_scope(
          expr,
          new_scope,
          aggcontext=aggcontext,
          clients=clients,
          post_execute_=post_execute_,
          **kwargs,
      )
docs: Execute until our op is in `scope`.
  
      Parameters
      ----------
      expr : ibis.expr.types.Expr
      scope : Mapping
      aggcontext : Optional[AggregationContext]
      clients : List[ibis.client.Client]
      kwargs : Mapping