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
|