1 """Drop-in replacement for the thread module.

     2 

     3 Meant to be used as a brain-dead substitute so that threaded code does

     4 not need to be rewritten for when the thread module is not present.

     5 

     6 Suggested usage is::

     7 

     8     try:

     9         import thread

    10     except ImportError:

    11         import dummy_thread as thread

    12 

    13 """

    14 # Exports only things specified by thread documentation;

    15 # skipping obsolete synonyms allocate(), start_new(), exit_thread().

    16 __all__ = ['error', 'start_new_thread', 'exit', 'get_ident', 'allocate_lock',

    17            'interrupt_main', 'LockType']

    18 

    19 import traceback as _traceback

    20 

    21 class error(Exception):

    22     """Dummy implementation of thread.error."""

    23 

    24     def __init__(self, *args):

    25         self.args = args

    26 

    27 def start_new_thread(function, args, kwargs={}):

    28     """Dummy implementation of thread.start_new_thread().

    29 

    30     Compatibility is maintained by making sure that ``args`` is a

    31     tuple and ``kwargs`` is a dictionary.  If an exception is raised

    32     and it is SystemExit (which can be done by thread.exit()) it is

    33     caught and nothing is done; all other exceptions are printed out

    34     by using traceback.print_exc().

    35 

    36     If the executed function calls interrupt_main the KeyboardInterrupt will be

    37     raised when the function returns.

    38 

    39     """

    40     if type(args) != type(tuple()):

    41         raise TypeError("2nd arg must be a tuple")

    42     if type(kwargs) != type(dict()):

    43         raise TypeError("3rd arg must be a dict")

    44     global _main

    45     _main = False

    46     try:

    47         function(*args, **kwargs)

    48     except SystemExit:

    49         pass

    50     except:

    51         _traceback.print_exc()

    52     _main = True

    53     global _interrupt

    54     if _interrupt:

    55         _interrupt = False

    56         raise KeyboardInterrupt

    57 

    58 def exit():

    59     """Dummy implementation of thread.exit()."""

    60     raise SystemExit

    61 

    62 def get_ident():

    63     """Dummy implementation of thread.get_ident().

    64 

    65     Since this module should only be used when threadmodule is not

    66     available, it is safe to assume that the current process is the

    67     only thread.  Thus a constant can be safely returned.

    68     """

    69     return -1

    70 

    71 def allocate_lock():

    72     """Dummy implementation of thread.allocate_lock()."""

    73     return LockType()

    74 

    75 def stack_size(size=None):

    76     """Dummy implementation of thread.stack_size()."""

    77     if size is not None:

    78         raise error("setting thread stack size not supported")

    79     return 0

    80 

    81 class LockType(object):

    82     """Class implementing dummy implementation of thread.LockType.

    83 

    84     Compatibility is maintained by maintaining self.locked_status

    85     which is a boolean that stores the state of the lock.  Pickling of

    86     the lock, though, should not be done since if the thread module is

    87     then used with an unpickled ``lock()`` from here problems could

    88     occur from this class not having atomic methods.

    89 

    90     """

    91 

    92     def __init__(self):

    93         self.locked_status = False

    94 

    95     def acquire(self, waitflag=None):

    96         """Dummy implementation of acquire().

    97 

    98         For blocking calls, self.locked_status is automatically set to

    99         True and returned appropriately based on value of

   100         ``waitflag``.  If it is non-blocking, then the value is

   101         actually checked and not set if it is already acquired.  This

   102         is all done so that threading.Condition's assert statements

   103         aren't triggered and throw a little fit.

   104 

   105         """

   106         if waitflag is None or waitflag:

   107             self.locked_status = True

   108             return True

   109         else:

   110             if not self.locked_status:

   111                 self.locked_status = True

   112                 return True

   113             else:

   114                 return False

   115 

   116     __enter__ = acquire

   117 

   118     def __exit__(self, typ, val, tb):

   119         self.release()

   120 

   121     def release(self):

   122         """Release the dummy lock."""

   123         # XXX Perhaps shouldn't actually bother to test?  Could lead

   124         #     to problems for complex, threaded code.

   125         if not self.locked_status:

   126             raise error

   127         self.locked_status = False

   128         return True

   129 

   130     def locked(self):

   131         return self.locked_status

   132 

   133 # Used to signal that interrupt_main was called in a "thread"

   134 _interrupt = False

   135 # True when not executing in a "thread"

   136 _main = True

   137 

   138 def interrupt_main():

   139     """Set _interrupt flag to True to have start_new_thread raise

   140     KeyboardInterrupt upon exiting."""

   141     if _main:

   142         raise KeyboardInterrupt

   143     else:

   144         global _interrupt

   145         _interrupt = True