# encoding: utf-8
# module faulthandler
# from (built-in)
# by generator 1.135
""" faulthandler module. """
# no imports

# functions

def cancel_dump_traceback_later(): # real signature unknown; restored from __doc__
    """
    cancel_dump_traceback_later():
    cancel the previous call to dump_traceback_later().
    """
    pass

def disable(): # real signature unknown; restored from __doc__
    """ disable(): disable the fault handler """
    pass

def dump_traceback(file=None, all_threads=True): # real signature unknown; restored from __doc__
    """ dump_traceback(file=sys.stderr, all_threads=True): dump the traceback of the current thread, or of all threads if all_threads is True, into file """
    pass

def dump_traceback_later(timeout, repeat=False, file=None, exit=False): # real signature unknown; restored from __doc__
    """
    dump_traceback_later(timeout, repeat=False, file=sys.stderrn, exit=False):
    dump the traceback of all threads in timeout seconds,
    or each timeout seconds if repeat is True. If exit is True, call _exit(1) which is not safe.
    """
    pass

def enable(file=None, all_threads=True): # real signature unknown; restored from __doc__
    """ enable(file=sys.stderr, all_threads=True): enable the fault handler """
    pass

def is_enabled(): # real signature unknown; restored from __doc__
    """ is_enabled()->bool: check if the handler is enabled """
    return False

def register(signum, file=None, all_threads=True, chain=False): # real signature unknown; restored from __doc__
    """ register(signum, file=sys.stderr, all_threads=True, chain=False): register an handler for the signal 'signum': dump the traceback of the current thread, or of all threads if all_threads is True, into file """
    pass

def unregister(signum): # real signature unknown; restored from __doc__
    """ unregister(signum): unregister the handler of the signal 'signum' registered by register() """
    pass

def _fatal_error(message): # real signature unknown; restored from __doc__
    """ _fatal_error(message): call Py_FatalError(message) """
    pass

def _read_null(release_gil=False): # real signature unknown; restored from __doc__
    """ _read_null(release_gil=False): read from NULL, raise a SIGSEGV or SIGBUS signal depending on the platform """
    pass

def _sigabrt(): # real signature unknown; restored from __doc__
    """ _sigabrt(): raise a SIGABRT signal """
    pass

def _sigbus(): # real signature unknown; restored from __doc__
    """ _sigbus(): raise a SIGBUS signal """
    pass

def _sigfpe(): # real signature unknown; restored from __doc__
    """ _sigfpe(): raise a SIGFPE signal """
    pass

def _sigill(): # real signature unknown; restored from __doc__
    """ _sigill(): raise a SIGILL signal """
    pass

def _sigsegv(): # real signature unknown; restored from __doc__
    """ _sigsegv(): raise a SIGSEGV signal """
    pass

def _stack_overflow(): # real signature unknown; restored from __doc__
    """ _stack_overflow(): recursive call to raise a stack overflow """
    pass

# classes

from .object import object

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.
    """
    @classmethod
    def find_module(cls, *args, **kwargs): # real signature unknown
        """
        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

    @classmethod
    def find_spec(cls, *args, **kwargs): # real signature unknown
        pass

    @classmethod
    def get_code(cls, *args, **kwargs): # real signature unknown
        """ Return None as built-in modules do not have code objects. """
        pass

    @classmethod
    def get_source(cls, *args, **kwargs): # real signature unknown
        """ Return None as built-in modules do not have source code. """
        pass

    @classmethod
    def is_package(cls, *args, **kwargs): # real signature unknown
        """ Return False as built-in modules are never packages. """
        pass

    @classmethod
    def load_module(cls, *args, **kwargs): # real signature unknown
        """ Load a built-in module. """
        pass

    def module_repr(module): # reliably restored by inspect
        """
        Return repr for the module.
        
                The method is deprecated.  The import machinery does the job itself.
        """
        pass

    def __init__(self, *args, **kwargs): # real signature unknown
        pass

    __weakref__ = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
    """list of weak references to the object (if defined)"""


    __dict__ = None # (!) real value is ''


# variables with complex values

__spec__ = None # (!) real value is ''

