wxPython/wxversion/wxversion.py

   1 #----------------------------------------------------------------------
   2 # Name:        wxversion
   3 # Purpose:     Allows a wxPython program to search for alternate
   4 #              installations of the wxPython packages and modify sys.path
   5 #              so they will be found when "import wx" is done.
   6 #
   7 # Author:      Robin Dunn
   8 #
   9 # Created:     24-Sept-2004
  10 # RCS-ID:      $Id$
  11 # Copyright:   (c) 2004 by Total Control Software
  12 # Licence:     wxWindows license
  13 #----------------------------------------------------------------------
  14
  15 """
  16 If you have more than one version of wxPython installed this module
  17 allows your application to choose which version of wxPython will be
  18 imported when it does 'import wx'.  You use it like this:
  19
  20     import wxversion
  21     wxversion.require('2.4')
  22     import wx
  23
  24 Of course the default wxPython version can also be controlled by
  25 setting PYTHONPATH or by editing the wx.pth path configuration file,
  26 but using wxversion will allow an application to manage the version
  27 selection itself rather than depend on the user to setup the
  28 environment correctly.
  29
  30 It works by searching the sys.path for directories matching wx-* and
  31 then comparing them to what was passed to the require function.  If a
  32 match is found then that path is inserted into sys.path.
  33 """
  34
  35 import sys, os, glob, fnmatch
  36
  37
  38
  39
  40 def require(versions):
  41     """
  42     Search for a wxPython installation that matches version.
  43
  44         :param version: Specifies the version to look for, it can either be
  45                         a sting or a list of strings.  Each string is
  46                         compared to the installed wxPythons and the best
  47                         match is added to the sys.path, allowing an 'import
  48                         wx' to find that version.
  49
  50                         The version string is composed of the dotted
  51                         version number (at least 2 of the 4 components)
  52                         optionally followed by hyphen ('-') separated
  53                         options (wx port, unicode/ansi, flavour, etc.)  A
  54                         match is determined by how much of the installed
  55                         version matches what is given in the version
  56                         parameter.  If the version number components don't
  57                         match then the score is zero, otherwise the score
  58                         is increased for every specified optional component
  59                         that is specified and that matches.
  60     """
  61     assert not sys.modules.has_key('wx') and not sys.modules.has_key('wxPython'), \
  62            "wxversion.require() must be called before wxPython is imported"
  63
  64     bestMatch = None
  65     bestScore = 0
  66     if type(versions) == str:
  67         versions = [versions]
  68
  69     packages = _find_installed()
  70     for pkg in packages:
  71         for ver in versions:
  72             score = pkg.Score(_wxPackageInfo(ver))
  73             if score > bestScore:
  74                 bestMatch = pkg
  75                 bestScore = score
  76
  77     assert bestMatch is not None, \
  78            "Required version of wxPython not found"
  79
  80     sys.path.insert(0, bestMatch.pathname)
  81
  82
  83
  84
  85 _pattern = "wx-[0-9].*"
  86 def _find_installed():
  87     installed = []
  88     toRemove = []
  89     for pth in sys.path:
  90
  91         # empty means to look in the current dir
  92         if not pth:
  93             pth = '.'
  94
  95         # skip it if it's not a package dir
  96         if not os.path.isdir(pth):
  97             continue
  98
  99         base = os.path.basename(pth)
 100
 101         # if it's a wx path that's already in the sys.path then mark
 102         # it for removal and then skip it
 103         if fnmatch.fnmatchcase(base, _pattern):
 104             toRemove.append(pth)
 105             continue
 106
 107         # now look in the dir for matching subdirs
 108         for name in glob.glob(os.path.join(pth, _pattern)):
 109             # make sure it's a directory
 110             if not os.path.isdir(name):
 111                 continue
 112             # and has a wx subdir
 113             if not os.path.exists(os.path.join(name, 'wx')):
 114                 continue
 115             installed.append(_wxPackageInfo(name, True))
 116
 117     for rem in toRemove:
 118         del sys.path[sys.path.index(rem)]
 119
 120     installed.sort()
 121     installed.reverse()
 122     return installed
 123
 124
 125 class _wxPackageInfo(object):
 126     def __init__(self, pathname, stripFirst=False):
 127         self.pathname = pathname
 128         base = os.path.basename(pathname)
 129         segments = base.split('-')
 130         if stripFirst:
 131             segments = segments[1:]
 132         self.version = tuple([int(x) for x in segments[0].split('.')])
 133         self.options = segments[1:]
 134
 135
 136     def Score(self, other):
 137         score = 0
 138         # whatever version components given in other must match exactly
 139         if len(self.version) > len(other.version):
 140             v = self.version[:len(other.version)]
 141         else:
 142             v = self.version
 143         if v != other.version:
 144             return 0
 145         score += 1
 146         for opt in other.options:
 147             if opt in self.options:
 148                 score += 1
 149         return score
 150
 151
 152     # TODO: factor self.options into the sort order?
 153     def __lt__(self, other):
 154         return self.version < other.version
 155     def __gt__(self, other):
 156         return self.version > other.version
 157     def __eq__(self, other):
 158         return self.version == other.version
 159
 160
 161
 162
 163
 164 if __name__ == '__main__':
 165     import pprint
 166     def test(version):
 167         savepath = sys.path[:]
 168         require(version)
 169         print "Asked for %s:\t got: %s" % (version, sys.path[0])
 170         pprint.pprint(sys.path)
 171         print
 172         sys.path = savepath[:]
 173
 174
 175     # make some test dirs
 176     names = ['wx-2.4',
 177              'wx-2.5.2',
 178              'wx-2.5.2.9-gtk2-unicode',
 179              'wx-2.5.2.9-gtk-ansi',
 180              'wx-2.5.1',
 181              'wx-2.5.2.8-gtk2-unicode',
 182              'wx-2.5.3']
 183     for name in names:
 184         d = os.path.join('/tmp', name)
 185         os.mkdir(d)
 186         os.mkdir(os.path.join(d, 'wx'))
 187
 188     # setup sys.path to see those dirs
 189     sys.path.append('/tmp')
 190
 191
 192     # now run some tests
 193     test("2.4")
 194     test("2.5")
 195     test("2.5-gtk2")
 196     test("2.5.2")
 197     test("2.5-ansi")
 198     test("2.5-unicode")
 199
 200     # There isn't a unicode match for this one, but it will give the best
 201     # available 2.4.  Should it give an error instead?  I don't think so...
 202     test("2.4-unicode")
 203
 204     try:
 205         # expecting an error on this one
 206         test("2.6")
 207     except AssertionError:
 208         print "Asked for 2.6:\t got: Assertion"
 209
 210     # Try asking for multiple versions
 211     test(["2.6", "2.5.3", "2.5.2-gtk2"])
 212
 213     # cleanup
 214     for name in names:
 215         d = os.path.join('/tmp', name)
 216         os.rmdir(os.path.join(d, 'wx'))
 217         os.rmdir(d)
 218
 219