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
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
|
# This program is free software; you can redistribute it and/or modify it under
# the terms of the GNU General Public License as published by the Free Software
# Foundation; either version 2 of the License, or (at your option) any later
# version.
#
# This program is distributed in the hope that it will be useful, but WITHOUT
# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
# FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License along with
# this program; if not, write to the Free Software Foundation, Inc.,
# 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
"""astng manager: avoid multible astng build of a same module when
possible by providing a class responsible to get astng representation
from various source and using a cache of built modules)
:version: $Revision: 1.49 $
:author: Sylvain Thenault
:copyright: 2003-2005 LOGILAB S.A. (Paris, FRANCE)
:contact: http://www.logilab.fr/ -- mailto:python-projects@logilab.org
:copyright: 2003-2005 Sylvain Thenault
:contact: mailto:thenault@gmail.com
"""
__revision__ = "$Id: manager.py,v 1.49 2006-03-08 15:52:30 syt Exp $"
__doctype__ = "restructuredtext en"
import sys
import os
from os.path import dirname, basename, abspath, join, isdir, exists
from logilab.common.cache import Cache
from logilab.common.modutils import NoSourceFile, is_python_source, \
file_from_modpath, load_module_from_name, \
get_module_files, get_source_file
from logilab.common.configuration import OptionsProviderMixIn
from logilab.astng._exceptions import ASTNGBuildingException
def astng_wrapper(func, modname):
"""wrapper to give to ASTNGManager.project_from_files"""
print 'parsing %s...' % modname
try:
return func(modname)
except ASTNGBuildingException, ex:
print ex
except KeyboardInterrupt:
raise
except Exception, ex:
import traceback
traceback.print_exc()
class ASTNGManager(OptionsProviderMixIn):
"""the astng manager, responsible to build astng from files
or modules.
Use the Borg pattern.
"""
name = 'astng loader'
options = (("ignore",
{'type' : "csv", 'metavar' : "<file>",
'dest' : "black_list", "default" : ('CVS',),
'help' : "add <file> (may be a directory) to the black list\
. It should be a base name, not a path. You may set this option multiple times\
."}),
("project",
{'default': "No Name", 'type' : 'string', 'short': 'p',
'metavar' : '<project name>',
'help' : 'set the project name.'}),
)
brain = {}
def __init__(self):
self.__dict__ = ASTNGManager.brain
if not self.__dict__:
OptionsProviderMixIn.__init__(self)
self._cache = None
self._mod_file_cache = None
self.set_cache_size(200)
def set_cache_size(self, cache_size):
"""set the cache size (flush it as a side effect!)"""
self._cache = {} #Cache(cache_size)
self._mod_file_cache = {}
def from_directory(self, directory, modname=None):
"""given a module name, return the astng object"""
modname = modname or basename(directory)
directory = abspath(directory)
return Package(directory, modname, self)
def astng_from_file(self, filepath, modname=None, fallback=True):
"""given a module name, return the astng object"""
try:
filepath = get_source_file(filepath, include_no_ext=True)
source = True
except NoSourceFile:
source = False
try:
return self._cache[filepath]
except KeyError:
if source:
try:
from logilab.astng.builder import ASTNGBuilder
astng = ASTNGBuilder().file_build(filepath, modname)
except SyntaxError:
raise
except Exception, ex:
#if __debug__:
# import traceback
# traceback.print_exc()
msg = 'Unable to load module %s (%s)' % (modname, ex)
raise ASTNGBuildingException(msg), None, sys.exc_info()[-1]
elif fallback and modname:
return self.astng_from_module_name(modname)
else:
raise ASTNGBuildingException('unable to get astng for file %s' %
filepath)
self._cache[filepath] = astng
return astng
from_file = astng_from_file # backward compat
def astng_from_module_name(self, modname, context_file=None):
"""given a module name, return the astng object"""
old_cwd = os.getcwd()
if context_file:
os.chdir(dirname(context_file))
try:
filepath = self.file_from_module_name(modname, context_file)
if filepath is None or not is_python_source(filepath):
try:
module = load_module_from_name(modname)
except ImportError, ex:
msg = 'Unable to load module %s (%s)' % (modname, ex)
raise ASTNGBuildingException(msg)
return self.astng_from_module(module, modname)
return self.astng_from_file(filepath, modname, fallback=False)
finally:
os.chdir(old_cwd)
def file_from_module_name(self, modname, contextfile):
try:
value = self._mod_file_cache[(modname, contextfile)]
except KeyError:
try:
value = file_from_modpath(modname.split('.'),
context_file=contextfile)
except ImportError, ex:
msg = 'Unable to load module %s (%s)' % (modname, ex)
value = ASTNGBuildingException(msg)
self._mod_file_cache[(modname, contextfile)] = value
if isinstance(value, ASTNGBuildingException):
raise value
return value
def astng_from_module(self, module, modname=None):
"""given an imported module, return the astng object"""
modname = modname or module.__name__
filepath = modname
try:
# some builtin modules don't have __file__ attribute
filepath = module.__file__
if is_python_source(filepath):
return self.astng_from_file(filepath, modname)
except AttributeError:
pass
try:
return self._cache[filepath]
except KeyError:
from logilab.astng.builder import ASTNGBuilder
astng = ASTNGBuilder().module_build(module, modname)
# update caches (filepath and astng.file are not necessarily the
# same (.pyc pb))
self._cache[filepath] = self._cache[astng.file] = astng
return astng
def astng_from_class(self, klass, modname=None):
"""get astng for the given class"""
if modname is None:
try:
modname = klass.__module__
except AttributeError:
raise ASTNGBuildingException(
'Unable to get module for class %s' % klass)
modastng = self.astng_from_module_name(modname)
return modastng.getattr(klass.__name__)[0] # XXX
def project_from_files(self, files, func_wrapper=astng_wrapper,
project_name=None, black_list=None):
"""return a Project from a list of files or modules"""
# insert current working directory to the python path to have a correct
# behaviour
sys.path.insert(0, os.getcwd())
try:
# build the project representation
project_name = project_name or self.config.project
black_list = black_list or self.config.black_list
project = Project(project_name)
for something in files:
if not exists(something):
fpath = file_from_modpath(something.split('.'))
elif isdir(something):
fpath = join(something, '__init__.py')
else:
fpath = something
astng = func_wrapper(self.astng_from_file, fpath)
if astng is None:
continue
project.path = project.path or astng.file
project.add_module(astng)
base_name = astng.name
# recurse in package except if __init__ was explicitly given
if astng.package and something.find('__init__') == -1:
# recurse on others packages / modules if this is a package
for fpath in get_module_files(dirname(astng.file),
black_list):
astng = func_wrapper(self.astng_from_file, fpath)
if astng is None or astng.name == base_name:
continue
project.add_module(astng)
return project
finally:
sys.path.pop(0)
class Package:
"""a package using a dictionary like interface
load submodules lazily, as they are needed
"""
def __init__(self, path, name, manager):
self.name = name
self.path = abspath(path)
self.manager = manager
self.parent = None
self.lineno = 0
self.__keys = None
self.__subobjects = None
def fullname(self):
"""return the full name of the package (i.e. prefix by the full name
of the parent package if any
"""
if self.parent is None:
return self.name
return '%s.%s' % (self.parent.fullname(), self.name)
def get_subobject(self, name):
"""method used to get sub-objects lazily : sub package or module are
only build once they are requested
"""
if self.__subobjects is None:
try:
self.__subobjects = dict.fromkeys(self.keys())
except AttributeError:
# python <= 2.3
self.__subobjects = dict([(k, None) for k in self.keys()])
obj = self.__subobjects[name]
if obj is None:
objpath = join(self.path, name)
if isdir(objpath):
obj = Package(objpath, name, self.manager)
obj.parent = self
else:
modname = '%s.%s' % (self.fullname(), name)
obj = self.manager.astng_from_file(objpath + '.py', modname)
self.__subobjects[name] = obj
return obj
def get_module(self, modname):
"""return the Module or Package object with the given name if any
"""
path = modname.split('.')
if path[0] != self.name:
raise KeyError(modname)
obj = self
for part in path[1:]:
obj = obj.get_subobject(part)
return obj
def keys(self):
if self.__keys is None:
self.__keys = []
for fname in os.listdir(self.path):
if fname.endswith('.py'):
self.__keys.append(fname[:-3])
continue
fpath = join(self.path, fname)
if isdir(fpath) and exists(join(fpath, '__init__.py')):
self.__keys.append(fname)
self.__keys.sort()
return self.__keys[:]
def values(self):
return [self.get_subobject(name) for name in self.keys()]
def items(self):
return zip(self.keys(), self.values())
def has_key(self, name):
return bool(self.get(name))
def get(self, name, default=None):
try:
return self.get_subobject(name)
except KeyError:
return default
def __getitem__(self, name):
return self.get_subobject(name)
def __contains__(self, name):
return self.has_key(name)
def __iter__(self):
return iter(self.keys())
class Project:
"""a project handle a set of modules / packages"""
def __init__(self, name=''):
self.name = name
self.path = None
self.modules = []
self.locals = {}
self.__getitem__ = self.locals.__getitem__
self.__iter__ = self.locals.__iter__
self.values = self.locals.values
self.keys = self.locals.keys
self.has_key = self.locals.has_key
def add_module(self, node):
self.locals[node.name] = node
self.modules.append(node)
def get_module(self, name):
return self.locals[name]
def getChildNodes(self):
return self.modules
def __repr__(self):
return '<Project %r at %s (%s modules)>' % (self.name, id(self),
len(self.modules))
|