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_function(
      self,
      tx,
      args: "List[VariableTracker]",
      kwargs: "Dict[str, VariableTracker]",
  ) -> "VariableTracker":
      from .. import trace_rules
      from .builder import VariableBuilder
  
      if (
          self.is_supported_random()
          and all(k.is_python_constant() for k in args)
          and all(v.is_python_constant() for v in kwargs.values())
      ):
          args = [x.as_python_constant() for x in args]
          kwargs = {
              k: v.as_python_constant() for k, v in kwargs.items()
          }
          random_call_index = len(tx.random_calls)
          example_value = self.value(*args, **kwargs)
          source = RandomValueSource(random_call_index)
          tx.random_calls.append((self.value, args, kwargs))
          return VariableBuilder(
              tx, source
          ).wrap_unspecialized_primitive(example_value)
      elif istype(self.value, types.MethodType):
          func = self.value.__func__
          obj = self.value.__self__
          if (
              func
              is torch.utils._contextlib._DecoratorContextManager.clone
              and trace_rules.lookup(obj.__class__)
              == variables.TorchCtxManagerClassVariable
              and not (args or kwargs)
          ):
              return variables.TorchCtxManagerClassVariable(
                  obj.__class__
              ).call_function(tx, args, kwargs)
  
          if (
              func is torch.autograd.grad_mode.inference_mode.clone
              and obj.__class__
              is torch.autograd.grad_mode.inference_mode
          ):
              # simulate the inference_mode.clone implementation
              var = variables.ConstantVariable(obj.mode)
              return variables.TorchCtxManagerClassVariable(
                  obj.__class__
              ).call_function(tx, [var], kwargs)
      elif (
          istype(self.value, functools.partial)
          and trace_rules.lookup(self.value.func)
          == variables.TorchInGraphFunctionVariable
          and all(
              variables.ConstantVariable.is_literal(v)
              for v in itertools.chain(
                  self.value.args, self.value.keywords.values()
              )
          )
      ):
          if self.source:
              install_guard(
                  AttrSource(self.source, "func").make_guard(
                      GuardBuilder.ID_MATCH
                  ),
                  AttrSource(self.source, "args").make_guard(
                      GuardBuilder.CONSTANT_MATCH
                  ),
                  AttrSource(self.source, "keywords").make_guard(
                      GuardBuilder.CONSTANT_MATCH
                  ),
              )
  
          partial_args = [
              variables.ConstantVariable.create(v)
              for v in self.value.args
          ]
          partial_args.extend(args)
          partial_kwargs = {
              k: variables.ConstantVariable.create(v)
              for k, v in self.value.keywords.items()
          }
          partial_kwargs.update(kwargs)
          if is_utils_checkpoint(self.value.func):
              return build_checkpoint_variable().call_function(
                  tx, partial_args, partial_kwargs
              )
          return variables.TorchInGraphFunctionVariable(
              self.value.func
          ).call_function(tx, partial_args, partial_kwargs)
      elif callable(self.value):
          if self.source:
              install_guard(
                  self.source.make_guard(GuardBuilder.FUNCTION_MATCH)
              )
          return self.call_method(tx, "__call__", args, kwargs)
  
      return super().call_function(tx, 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 12 for calling the UserDefinedObjectVariable obj's underlying member method code with example usage: obj.call_function(tx, args, kwargs) and returns: super, VariableBuilder, variables, variables, variables, build_checkpoint_variable, self