# coding: utf-8
# AUTO-GENERATED FILE -- DO NOT EDIT

""" Debug module to trace memory blocks allocated by Python. """

__doc__ = 'Debug module to trace memory blocks allocated by Python.'

class __loader__(object):
  """ Meta path import for built-in modules.
  
      All methods are either class or static methods to avoid the need to
      instantiate the class.
  
       """

  def create_module(self, spec):
    """ Create a built-in module """
    pass

  def exec_module(self, module):
    """ Exec a built-in module """
    pass

  def find_module(self, fullname, path=None):
    """ Find the built-in module.
    
            If 'path' is ever specified then the search is considered a failure.
    
            This method is deprecated.  Use find_spec() instead.
    
             """
    pass

  def find_spec(self, fullname, path=None, target=None):
    pass

  def get_code(self, fullname):
    """ Return None as built-in modules do not have code objects. """
    pass

  def get_source(self, fullname):
    """ Return None as built-in modules do not have source code. """
    pass

  def is_package(self, fullname):
    """ Return False as built-in modules are never packages. """
    pass

  def load_module(self, fullname):
    """ Load the specified module into sys.modules and return it.
    
        This method is deprecated.  Use loader.exec_module instead.
    
         """
    pass

  def module_repr(self, module):
    """ Return repr for the module.
    
            The method is deprecated.  The import machinery does the job itself.
    
             """
    pass

__name__ = '_tracemalloc'
__package__ = ''
__spec__ = None

def _get_object_traceback(obj):
  """ _get_object_traceback(obj)
  
  Get the traceback where the Python object obj was allocated.
  Return a tuple of (filename: str, lineno: int) tuples.
  
  Return None if the tracemalloc module is disabled or did not
  trace the allocation of the object. """
  pass

def _get_traces():
  """ _get_traces() -> list
  
  Get traces of all memory blocks allocated by Python.
  Return a list of (size: int, traceback: tuple) tuples.
  traceback is a tuple of (filename: str, lineno: int) tuples.
  
  Return an empty list if the tracemalloc module is disabled. """
  return []

def clear_traces():
  """ clear_traces()
  
  Clear traces of memory blocks allocated by Python. """
  pass

def get_traceback_limit():
  """ get_traceback_limit() -> int
  
  Get the maximum number of frames stored in the traceback
  of a trace.
  
  By default, a trace of an allocated memory block only stores
  the most recent frame: the limit is 1. """
  return 1

def get_traced_memory():
  """ get_traced_memory() -> (int, int)
  
  Get the current size and peak size of memory blocks traced
  by the tracemalloc module as a tuple: (current: int, peak: int). """
  return (1, 1)

def get_tracemalloc_memory():
  """ get_tracemalloc_memory() -> int
  
  Get the memory usage in bytes of the tracemalloc module
  used internally to trace memory allocations. """
  return 1

def is_tracing():
  """ is_tracing()->bool
  
  True if the tracemalloc module is tracing Python memory allocations,
  False otherwise. """
  return None

def start():
  """ start(nframe: int=1)
  
  Start tracing Python memory allocations. Set also the maximum number 
  of frames stored in the traceback of a trace to nframe. """
  pass

def stop():
  """ stop()
  
  Stop tracing Python memory allocations and clear traces
  of memory blocks allocated by Python. """
  pass