home *** CD-ROM | disk | FTP | other *** search
/ Chip 2011 November / CHIP_2011_11.iso / Programy / Narzedzia / Inkscape / Inkscape-0.48.2-1-win32.exe / python / Lib / dummy_thread.py < prev    next >
Encoding:
Python Source  |  2010-05-29  |  4.5 KB  |  146 lines
  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
  146.