1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
|
import sys, imp, __builtin__
import _irssi
class Output:
def __init__(self, level):
self.level = level
self.buf = []
def write(self, text):
if not text:
return
self.buf.append(text)
if '\n' == text[-1]:
text = ''.join(self.buf)[:-1]
for line in text.split('\\n'):
_irssi.active_win().prnt(line, self.level)
self.buf = []
#XXX: hardcode
#try:
sys.stdout = Output(level = 0x0080000)
sys.stderr = Output(level = 0x0100000)
#except Exception, e:
# print 'Cant set output', e
# sys.stdout = sys.__stdout__
# sys.stderr = sys.__stderr__
"""
#Import stuff modified from <Python>/Demo/imputil/knee.py
#If a script instance is available, it's module dictionary
#is used in place of sys.modules
#XXX: needs testing
#XXX: copyright?
# Save the original hooks
original_import = __builtin__.__import__
original_reload = __builtin__.reload
# Replacement for __import__()
def import_hook(name, globals=None, locals=None, fromlist=None):
print 'LOADING', name
if name == 'sys':
return sys
#if name == '_irssi':
# return _irssi
try:
script = _irssi.get_script()
except RuntimeError:
print 'ORIG IMPORT', name
return original_import(name, globals, locals, fromlist)
parent = determine_parent(globals, script)
q, tail = find_head_package(parent, name, script)
m = load_tail(q, tail, script)
if not fromlist:
return q
if hasattr(m, "__path__"):
ensure_fromlist(m, fromlist, script)
recur -= 1
return m
def determine_parent(globals, script):
if not globals or not globals.has_key("__name__"):
print 'DP no __name__ in globals'
return None
pname = globals['__name__']
print 'DP pname', pname
if globals.has_key("__path__"):
parent = script.modules[pname]
assert globals is parent.__dict__
return parent
if '.' in pname:
i = pname.rfind('.')
pname = pname[:i]
parent = script.modules[pname]
assert parent.__name__ == pname
return parent
return None
def find_head_package(parent, name, script):
if '.' in name:
i = name.find('.')
head = name[:i]
tail = name[i+1:]
else:
head = name
tail = ""
if parent:
qname = "%s.%s" % (parent.__name__, head)
else:
qname = head
q = import_module(head, qname, parent, script)
if q:
return q, tail
else:
print 'FHP (1) no q module for', name
if parent:
qname = head
parent = None
q = import_module(head, qname, parent, script)
if q:
return q, tail
else:
print 'FHP (2) no q module for', name
raise ImportError, "No module named " + qname
def load_tail(q, tail, script):
m = q
while tail:
i = tail.find('.')
if i < 0: i = len(tail)
head, tail = tail[:i], tail[i+1:]
mname = "%s.%s" % (m.__name__, head)
m = import_module(head, mname, m, script)
if not m:
raise ImportError, "No module named " + mname
return m
def ensure_fromlist(m, fromlist, script, recursive=0):
for sub in fromlist:
if sub == "*":
if not recursive:
try:
all = m.__all__
except AttributeError:
pass
else:
assert recursive == 0
ensure_fromlist(m, all, script, 1)
continue
if sub != "*" and not hasattr(m, sub):
subname = "%s.%s" % (m.__name__, sub)
submod = import_module(sub, subname, m, script)
if not submod:
raise ImportError, "No module named " + subname
def import_module(partname, fqname, parent, script):
try:
m = script.modules[fqname]
#if hasattr(m, '_script'):
# assert m._script == script
_irssi.prnt('LOADING CACHED %s script -> %s' % (fqname, repr(script)))
return m
except KeyError:
print 'IM no cached moddule for', fqname
pass
try:
fp, pathname, stuff = imp.find_module(partname,
parent and parent.__path__)
except ImportError, e:
print 'IM import error', e
return None
try:
m = imp.load_module(fqname, fp, pathname, stuff)
finally:
if fp: fp.close()
if parent:
setattr(parent, partname, m)
#don't load script into builtins, extensions, or this wrapper
if hasattr(m, '__file__') and fqname != 'irssi':
m._script = script
script.modules[fqname] = m
#if hasattr(m, '__file__') and fqname not in ('__builtin__', 'sys', '__main__', '_irssi'):
# del sys.modules[fqname]
_irssi.prnt('GOT -> %s, SCRIPT -> %s' % (m, repr(script)))
return m
# Replacement for reload()
def reload_hook(module):
_irssi.prnt('reloading ' + repr(module))
try:
script = _irssi.get_script()
except RuntimeError:
return original_reload(module)
name = module.__name__
if '.' not in name:
return import_module(name, name, None, script)
i = name.rfind('.')
pname = name[:i]
parent = script.modules[pname]
return import_module(name[i+1:], name, parent, script)
# Now install our hooks
__builtin__.__import__ = import_hook
__builtin__.reload = reload_hook
"""
|
