code: def create_context(
      self,
      base_context,
      node,
      node_is_context=False,
      node_is_object=False,
  ):
      def parent_scope(node):
          while True:
              node = node.parent
  
              if parser_utils.is_scope(node):
                  return node
              elif node.type in ("argument", "testlist_comp"):
                  if node.children[1].type == "comp_for":
                      return node.children[1]
              elif node.type == "dictorsetmaker":
                  for n in node.children[1:4]:
                      # In dictionaries it can be pretty much anything.
                      if n.type == "comp_for":
                          return n
  
      def from_scope_node(
          scope_node,
          child_is_funcdef=None,
          is_nested=True,
          node_is_object=False,
      ):
          if scope_node == base_node:
              return base_context
  
          is_funcdef = scope_node.type in ("funcdef", "lambdef")
          parent_scope = parser_utils.get_parent_scope(scope_node)
          parent_context = from_scope_node(
              parent_scope, child_is_funcdef=is_funcdef
          )
  
          if is_funcdef:
              func = FunctionContext.from_context(
                  parent_context, scope_node
              )
              if isinstance(parent_context, AnonymousInstance):
                  func = BoundMethod(
                      instance=parent_context,
                      klass=parent_context.class_context,
                      function=func,
                  )
              if is_nested and not node_is_object:
                  return func.get_function_execution()
              return func
          elif scope_node.type == "classdef":
              class_context = ClassContext(
                  self, parent_context, scope_node
              )
              if child_is_funcdef:
                  # anonymous instance
                  return AnonymousInstance(
                      self, parent_context, class_context
                  )
              else:
                  return class_context
          elif scope_node.type == "comp_for":
              if node.start_pos >= scope_node.children[-1].start_pos:
                  return parent_context
              return CompForContext.from_comp_for(
                  parent_context, scope_node
              )
          raise Exception("There's a scope that was not managed.")
  
      base_node = base_context.tree_node
  
      if node_is_context and parser_utils.is_scope(node):
          scope_node = node
      else:
          if (
              node.parent.type in ("funcdef", "classdef")
              and node.parent.name == node
          ):
              # When we're on class/function names/leafs that define the
              # object itself and not its contents.
              node = node.parent
          scope_node = parent_scope(node)
      return from_scope_node(
          scope_node, is_nested=True, node_is_object=node_is_object
      )
  
imports: from parso.python import tree
  import parso
  from parso import python_bytes_to_unicode
  from jedi import debug
  from jedi import parser_utils
  from jedi.evaluate.utils import unite
  from jedi.evaluate import imports
  from jedi.evaluate import recursion
  from jedi.evaluate.cache import evaluator_function_cache
  from jedi.evaluate import compiled
  from jedi.evaluate import helpers
  from jedi.evaluate.filters import TreeNameDefinition, ParamName
  from jedi.evaluate.base_context import ContextualizedName, ContextualizedNode, ContextSet, NO_CONTEXTS, iterate_contexts
  from jedi.evaluate.context import ClassContext, FunctionContext, AnonymousInstance, BoundMethod
  from jedi.evaluate.context.iterable import CompForContext
  from jedi.evaluate.syntax_tree import eval_trailer, eval_expr_stmt, eval_node, check_tuple_assignments
label_desc: Use image node_id 10 for calling the Evaluator obj's underlying member method code with example usage: obj.create_context(base_context, node, node_is_context, node_is_object) and returns: from_scope_node, base_context, func, node, func, AnonymousInstance, class_context, CompForContext, node, parent_context, n