/ - Diff - gvSIG scripting - gvSIG

     import sys
     from subprocess import Popen, PIPE
     def sys_path():
       if sys.getClassLoader()!=None:
         path = getattr(sys.getClassLoader(),"path",None)
         if path != None:
           return path(sys.path)
       path = [ folder for folder in sys.path if not folder.startswith("__") ]
       return path
     def _get_env():
         '''Extracts the environment PYTHONPATH and appends the current sys.path to
         those.'''
         env = dict(os.environ)
         env['PYTHONPATH'] = os.pathsep.join(sys.path)
         env['PYTHONPATH'] = os.pathsep.join(sys_path()))
         return env
     def lint(filename, options=None):

     PY_EXTS = ('.py', '.pyc', '.pyo', '.pyw', '.so', '.dll')
     def listdir(directory):
       #print "@@@ listdir ", repr(directory)
       if directory!=u'__pyclasspath__/':
         return os.listdir(directory)
       files = list()
       urls = sys.getClassLoader().getURLs()
       for url in urls:
         f = unicode(url)
         if f.startswith("file:") and f.endswith("/"):
           f = f[5:]
           for filename in os.listdir(f):
             files.append(filename)
       return files
     def join_ex(directory,filename):
       #print("### join_ex: ", repr(directory), repr(filename))
       if directory!=u'__pyclasspath__/':
         return join(directory,filename)
       return sys.getClassLoader().getResourcePath(join(directory,filename))
     def register_plugins(linter, directory):
         """load all module and package in the given directory, looking for a
         'register' function in each one, used to register pylint checkers
         """
         imported = {}
         for filename in listdir_ex(directory):
         for filename in os.listdir(directory):
             base, extension = splitext(filename)
             if base in imported or base == '__pycache__':
                 continue
             if extension in PY_EXTS and base != '__init__' or (
                     not extension and isdir(join_ex(directory, base))):
                     not extension and isdir(join(directory, base))):
                 try:
                     module = load_module_from_file(join_ex(directory, filename))
                     module = load_module_from_file(join(directory, filename))
                 except ValueError:
                     # empty module name (usually emacs auto-save files)
                     continue

     SYMBOLS_HELP = ("Deprecated. It was used to include symbolic ids of "
                     "messages in output. Use --msg-template instead.")
     def sys_path():
       if sys.getClassLoader()!=None:
         path = getattr(sys.getClassLoader(),"path",None)
         if path != None:
           return path(sys.path)
       path = [ folder for folder in sys.path if not folder.startswith("__") ]
       return path
     def _get_new_args(message):
         location = (
             message.abspath,
-...
         We avoid adding duplicate directories to sys.path.
         `sys.path` is reset to its original value upon exitign this context.
         """
         orig = list(sys.path)
         orig = list(sys_path())
         changes = []
         for arg in args:
             path = _get_python_path(arg)
-...
                 continue
             else:
                 changes.append(path)
         sys.path[:] = changes + sys.path
         sys.path[:] = changes + sys_path()
         try:
             yield
         finally:

         manager.register_transform(Module, transform, lambda n: n.name == module_name)
     def sys_path():
       if sys.getClassLoader()==None:
         return sys.path
       path = getattr(sys.getClassLoader(),"path",None)
       if path == None:
         return sys.path
       return path(sys.path)
     # load brain plugins
     from os import listdir
     from os.path import join, dirname
-...
         if getResourcePath!=None:
             _file_ = getResourcePath(_file_)
     BRAIN_MODULES_DIR = join(dirname(_file_), 'brain')
     if BRAIN_MODULES_DIR not in sys.path:
     if BRAIN_MODULES_DIR not in sys_path():
         # add it to the end of the list so user path take precedence
         sys.path.append(BRAIN_MODULES_DIR)
     # load modules in this directory

     IS_JYTHON = platform.python_implementation() == 'Jython'
     BUILTIN_MODULES = dict.fromkeys(sys.builtin_module_names, True)
     def sys_path():
       if sys.getClassLoader()!=None:
         path = getattr(sys.getClassLoader(),"path",None)
         if path != None:
           return path(sys.path)
       path = [ folder for folder in sys.path if not folder.startswith("__") ]
       return path
     class NoSourceFile(Exception):
         """exception raised when we are not able to get a python
-...
                                   if pkg]
                     if _check_init(path, submodpath[:-1]):
                         return extrapath[path_].split('.') + submodpath
         for path in sys.path:
         for path in sys_path():
             path = _cache_normalize_path(path)
             if path and os.path.normcase(base).startswith(path):
                 modpath = [pkg for pkg in base[len(path):].split(os.sep) if pkg]
                 if _check_init(path, modpath[:-1]):
                     return modpath
         raise ImportError('Unable to find module for %s in %s' % (
             filename, ', \n'.join(sys.path)))
             filename, ', \n'.join(sys_path())))
     def file_from_modpath(modpath, path=None, context_file=None):
-...
         """
         if not os.path.isdir(from_file):
             from_file = os.path.dirname(from_file)
         if from_file in sys.path:
         if from_file in sys_path():
             return False
         try:
             stream, _, _ = imp.find_module(modname.split('.')[0], [from_file])
-...
         # egg support compat
         try:
             pic = sys.path_importer_cache
             _path = (path is None and sys.path or path)
             _path = (path is None and sys_path() or path)
             for __path in _path:
                 if not __path in pic:
                     try:
-...
                     if extend_path or declare_namespace:
                         # extend_path is called, search sys.path for module/packages
                         # of this name see pkgutil.extend_path documentation
                         path = [os.path.join(p, *imported) for p in sys.path
                         path = [os.path.join(p, *imported) for p in sys_path()
                                 if os.path.isdir(os.path.join(p, *imported))]
                     else:
                         path = [mp_filename]

Application: gvSIG desktop » gvSIG scripting

Revision 1227