class_docstr: Mostly objects of defined type.  Catch-all for something where we only know the type.
class_docstr_tok: ["Mostly","objects","of","defined","type",".","Catch-all","for","something","where","we","only","know","the","type","."]
code: def call_method(
      self,
      tx,
      name,
      args: "List[VariableTracker]",
      kwargs: "Dict[str, VariableTracker]",
  ) -> "VariableTracker":
      from . import (
          BuiltinVariable,
          ConstantVariable,
          TupleVariable,
          UserMethodVariable,
      )
  
      method = self._maybe_get_baseclass_method(name)
      if method is not None:
          if method is object.__init__:
              return ConstantVariable.create(None)
  
          # [NOTE] OrderedDict, dict subtypes must always have source
          # We cannot instantiate such subtypes in-graph due to builtin __new__
          if method is collections.OrderedDict.keys:
              # subclass of OrderedDict
              assert not (args or kwargs)
              assert (
                  self.source
              )  # OrderedDict, dict subtypes must always have source
              keys = list(self.value.keys())
              assert all(map(ConstantVariable.is_literal, keys))
              install_guard(
                  self.source.make_guard(GuardBuilder.ODICT_KEYS)
              )
              return TupleVariable(
                  [ConstantVariable.create(k) for k in keys]
              )
  
          if (
              method
              in (
                  collections.OrderedDict.__contains__,
                  dict.__contains__,
              )
              and len(args) == 1
              and isinstance(
                  args[0], (ConstantVariable, BuiltinVariable)
              )
              and inspect.getattr_static(type(self.value), "keys")
              in (collections.OrderedDict.keys, dict.keys)
          ):
              assert not kwargs
              assert (
                  self.source
              )  # OrderedDict, dict subtypes must always have source
              install_guard(
                  self.source.make_guard(GuardBuilder.ODICT_KEYS)
              )
              return ConstantVariable.create(
                  args[0].as_python_constant() in self.value
              )
  
          if method is collections.OrderedDict.items and isinstance(
              self.value, collections.OrderedDict
          ):
              assert (
                  self.source
              )  # OrderedDict, dict subtypes must always have source
              assert not (args or kwargs)
              items = []
              keys = self.call_method(tx, "keys", [], {})
              for key in keys.unpack_var_sequence(tx):
                  items.append(
                      TupleVariable(
                          [key, self.odict_getitem(tx, key)],
                      )
                  )
              return TupleVariable(items)
  
          if (
              method is collections.OrderedDict.__getitem__
              and len(args) == 1
          ):
              assert not kwargs
              assert (
                  self.source
              )  # OrderedDict, dict subtypes must always have source
              return self.odict_getitem(tx, args[0])
  
          # check for methods implemented in C++
          if isinstance(method, types.FunctionType):
              source = (
                  None
                  if self.source is None
                  else AttrSource(
                      AttrSource(self.source, "__class__"), name
                  )
              )
              # TODO(jansel): add a guard to check for monkey patching?
              return UserMethodVariable(
                  method, self, source=source
              ).call_function(tx, args, kwargs)
  
          if (
              method is list.__len__
              and self.source
              and not (args or kwargs)
          ):
              install_guard(
                  self.source.make_guard(GuardBuilder.LIST_LENGTH)
              )
              return ConstantVariable(len(self.value))
  
      return super().call_method(tx, name, args, kwargs)
  
imports: import collections
  import contextlib
  import functools
  import importlib
  import inspect
  import itertools
  import random
  import sys
  import threading
  import types
  from typing import Dict, List
  import torch._dynamo.config
  import torch.nn
  from torch._guards import TracingContext
  from ..None import variables
  from ..exc import unimplemented
  from ..guards import GuardBuilder, install_guard
  from ..source import AttrSource, GetItemSource, ODictGetItemSource, RandomValueSource
  from ..utils import all_hook_names, build_checkpoint_variable, check_constant_args, get_custom_getattr, has_torch_function, is_namedtuple_cls, is_utils_checkpoint, istype, namedtuple_fields, object_has_getattribute, proxy_args_kwargs, tensortype_to_dtype
  from .base import MutableLocal, VariableTracker
  from .ctx_manager import GenericContextWrappingVariable, NullContextVariable
  from .dicts import DefaultDictVariable
label_desc: Use image node_id 9 for calling the UserDefinedObjectVariable obj's underlying member method code with example usage: obj.call_method(tx, name, args, kwargs) and returns: super, ConstantVariable, TupleVariable, ConstantVariable, TupleVariable, self, UserMethodVariable, ConstantVariable