Allow art provider IDs for the extra bitmaps in a wxBitmapButton. (The

[wxWidgets.git] / wxPython / wxversion / wxversion.py

diff --git a/wxPython/wxversion/wxversion.py b/wxPython/wxversion/wxversion.py
index ca7f2c505521f707c6d56193c6294557273d50bf..cd10d44644b331e270ce333a469c140373d59c78 100644 (file)
--- a/wxPython/wxversion/wxversion.py
+++ b/wxPython/wxversion/wxversion.py
@@ -15,18 +15,34 @@
 """
 If you have more than one version of wxPython installed this module
 allows your application to choose which version of wxPython will be
 """
 If you have more than one version of wxPython installed this module
 allows your application to choose which version of wxPython will be

-imported when it does 'import wx'.  You use it like this::
+imported when it does 'import wx'.  The main function of this module
+is `select` and you use it like this::

 
     import wxversion
     wxversion.select('2.4')
     import wx
 
 
     import wxversion
     wxversion.select('2.4')
     import wx
 

-Or additional build options can also be selected, like this::
+Or additional build options can also be selected, although they will
+not be required if they are not installed, like this::

 
     import wxversion
     wxversion.select('2.5.3-unicode')
     import wx
 
 
     import wxversion
     wxversion.select('2.5.3-unicode')
     import wx
 

+Or you can require an exact match on the build options like this::
+
+    import wxversion
+    wxversion.select('2.5.3-unicode', optionsRequired=True)
+    import wx
+
+Finally you can also specify a collection of versions that are allowed
+by your application, like this::
+
+    import wxversion
+    wxversion.select(['2.5.4', '2.5.5', '2.6'])
+    import wx
+
+

 Of course the default wxPython version can also be controlled by
 setting PYTHONPATH or by editing the wx.pth path configuration file,
 but using wxversion will allow an application to manage the version
 Of course the default wxPython version can also be controlled by
 setting PYTHONPATH or by editing the wx.pth path configuration file,
 but using wxversion will allow an application to manage the version


@@ -34,13 +50,13 @@ selection itself rather than depend on the user to setup the
 environment correctly.
 
 It works by searching the sys.path for directories matching wx-* and
 environment correctly.
 
 It works by searching the sys.path for directories matching wx-* and

-then comparing them to what was passed to the require function.  If a
+then comparing them to what was passed to the select function.  If a

 match is found then that path is inserted into sys.path.
 
 NOTE: If you are making a 'bundle' of your application with a tool
 like py2exe then you should *not* use the wxversion module since it
 match is found then that path is inserted into sys.path.
 
 NOTE: If you are making a 'bundle' of your application with a tool
 like py2exe then you should *not* use the wxversion module since it

-looks at filesystem for the directories on sys.path, it will fail in a
-bundled environment.  Instead you should simply ensure that the
+looks at the filesystem for the directories on sys.path, it will fail
+in a bundled environment.  Instead you should simply ensure that the

 version of wxPython that you want is found by default on the sys.path
 when making the bundled version by setting PYTHONPATH.  Then that
 version will be included in your bundle and your app will work as
 version of wxPython that you want is found by default on the sys.path
 when making the bundled version by setting PYTHONPATH.  Then that
 version will be included in your bundle and your app will work as


@@ -53,9 +69,12 @@ that and only use wxversion if needed.  For example, for py2exe::
         wxversion.select('2.5')
     import wx
 
         wxversion.select('2.5')
     import wx
 

+More documentation on wxversion and multi-version installs can be
+found at: http://wiki.wxpython.org/index.cgi/MultiVersionInstalls
+

 """
 
 """
 

-import sys, os, glob, fnmatch
+import re, sys, os, glob, fnmatch

 
 
 _selected = None
 
 
 _selected = None


@@ -64,7 +83,7 @@ class VersionError(Exception):
 
 #----------------------------------------------------------------------
 
 
 #----------------------------------------------------------------------
 

-def select(versions):
+def select(versions, optionsRequired=False):

     """
     Search for a wxPython installation that matches version.  If one
     is found then sys.path is modified so that version will be
     """
     Search for a wxPython installation that matches version.  If one
     is found then sys.path is modified so that version will be


@@ -72,23 +91,36 @@ def select(versions):
     raised.  This funciton should only be caled once at the begining
     of the application before wxPython is imported.
 
     raised.  This funciton should only be caled once at the begining
     of the application before wxPython is imported.
 

-        :param version: Specifies the version to look for, it can
-                        either be a string or a list of strings.  Each
-                        string is compared to the installed wxPythons
-                        and the best match is inserted into the
-                        sys.path, allowing an 'import wx' to find that
-                        version.
-
-                        The version string is composed of the dotted
-                        version number (at least 2 of the 4 components)
-                        optionally followed by hyphen ('-') separated
-                        options (wx port, unicode/ansi, flavour, etc.)  A
-                        match is determined by how much of the installed
-                        version matches what is given in the version
-                        parameter.  If the version number components don't
-                        match then the score is zero, otherwise the score
-                        is increased for every specified optional component
-                        that is specified and that matches.
+        :param versions: Specifies the version to look for, it can
+            either be a string or a list of strings.  Each string is
+            compared to the installed wxPythons and the best match is
+            inserted into the sys.path, allowing an 'import wx' to
+            find that version.
+
+            The version string is composed of the dotted version
+            number (at least 2 of the 4 components) optionally
+            followed by hyphen ('-') separated options (wx port,
+            unicode/ansi, flavour, etc.)  A match is determined by how
+            much of the installed version matches what is given in the
+            version parameter.  If the version number components don't
+            match then the score is zero, otherwise the score is
+            increased for every specified optional component that is
+            specified and that matches.
+
+            Please note, however, that it is possible for a match to
+            be selected that doesn't exactly match the versions
+            requested.  The only component that is required to be
+            matched is the version number.  If you need to require a
+            match on the other components as well, then please use the
+            optional ``optionsRequired`` parameter described next.
+
+        :param optionsRequired: Allows you to specify that the other
+             components of the version string (such as the port name
+             or character type) are also required to be present for an
+             installed version to be considered a match.  Using this
+             parameter allows you to change the selection from a soft,
+             as close as possible match to a hard, exact match.
+        

     """
     if type(versions) == str:
         versions = [versions]
     """
     if type(versions) == str:
         versions = [versions]


@@ -98,44 +130,121 @@ def select(versions):
         # A version was previously selected, ensure that it matches
         # this new request
         for ver in versions:
         # A version was previously selected, ensure that it matches
         # this new request
         for ver in versions:

-            if _selected.Score(_wxPackageInfo(ver)) > 0:
+            if _selected.Score(_wxPackageInfo(ver), optionsRequired) > 0:

                 return
         # otherwise, raise an exception
         raise VersionError("A previously selected wx version does not match the new request.")
 
                 return
         # otherwise, raise an exception
         raise VersionError("A previously selected wx version does not match the new request.")
 

-    # If we get here then this is the first time wxversion is used.
-    # Ensure that wxPython hasn't been imported yet.
+    # If we get here then this is the first time wxversion is used, 
+    # ensure that wxPython hasn't been imported yet.

     if sys.modules.has_key('wx') or sys.modules.has_key('wxPython'):
     if sys.modules.has_key('wx') or sys.modules.has_key('wxPython'):

-        raise VersionError("wxversion.require() must be called before wxPython is imported")
-
+        raise VersionError("wxversion.select() must be called before wxPython is imported")
+    

     # Look for a matching version and manipulate the sys.path as
     # needed to allow it to be imported.
     # Look for a matching version and manipulate the sys.path as
     # needed to allow it to be imported.

-    packages = _find_installed(True)
-    bestMatch = _get_best_match(packages, versions)
+    installed = _find_installed(True)
+    bestMatch = _get_best_match(installed, versions, optionsRequired)

     
     if bestMatch is None:
         raise VersionError("Requested version of wxPython not found")
 
     sys.path.insert(0, bestMatch.pathname)
     
     if bestMatch is None:
         raise VersionError("Requested version of wxPython not found")
 
     sys.path.insert(0, bestMatch.pathname)

+    # q.v. Bug #1409256
+    path64 = re.sub('/lib/','/lib64/',bestMatch.pathname)
+    if os.path.isdir(path64):
+        sys.path.insert(0, path64)

     _selected = bestMatch
         
 #----------------------------------------------------------------------
 
     _selected = bestMatch
         
 #----------------------------------------------------------------------
 

-def checkInstalled(versions):
+UPDATE_URL = "http://wxPython.org/"
+#UPDATE_URL = "http://sourceforge.net/project/showfiles.php?group_id=10718"
+
+_EM_DEBUG=0
+
+def ensureMinimal(minVersion, optionsRequired=False):
+    """
+    Checks to see if the default version of wxPython is greater-than
+    or equal to `minVersion`.  If not then it will try to find an
+    installed version that is >= minVersion.  If none are available
+    then a message is displayed that will inform the user and will
+    offer to open their web browser to the wxPython downloads page,
+    and will then exit the application.
+    """
+    assert type(minVersion) == str
+
+    # ensure that wxPython hasn't been imported yet.
+    if sys.modules.has_key('wx') or sys.modules.has_key('wxPython'):
+        raise VersionError("wxversion.ensureMinimal() must be called before wxPython is imported")
+
+    bestMatch = None
+    minv = _wxPackageInfo(minVersion)
+
+    # check the default version first
+    defaultPath = _find_default()
+    if defaultPath:
+        defv = _wxPackageInfo(defaultPath, True)
+        if defv >= minv and minv.CheckOptions(defv, optionsRequired):
+            bestMatch = defv
+
+    # if still no match then check look at all installed versions
+    if bestMatch is None:
+        installed = _find_installed()
+        # The list is in reverse sorted order, so find the first
+        # one that is big enough and optionally matches the
+        # options
+        for inst in installed:
+            if inst >= minv and minv.CheckOptions(inst, optionsRequired):
+                bestMatch = inst
+                break
+
+    # if still no match then prompt the user
+    if bestMatch is None:
+        if _EM_DEBUG: # We'll do it this way just for the test code below
+            raise VersionError("Requested version of wxPython not found")
+        
+        import wx, webbrowser
+        versions = "\n".join(["      "+ver for ver in getInstalled()])
+        app = wx.PySimpleApp()
+        result = wx.MessageBox("This application requires a version of wxPython "
+                               "greater than or equal to %s, but a matching version "
+                               "was not found.\n\n"
+                               "You currently have these version(s) installed:\n%s\n\n"
+                               "Would you like to download a new version of wxPython?\n"
+                               % (minVersion, versions),
+                      "wxPython Upgrade Needed", style=wx.YES_NO)
+        if result == wx.YES:
+            webbrowser.open(UPDATE_URL)
+        app.MainLoop()
+        sys.exit()
+
+    sys.path.insert(0, bestMatch.pathname)
+    # q.v. Bug #1409256
+    path64 = re.sub('/lib/','/lib64/',bestMatch.pathname)
+    if os.path.isdir(path64):
+        sys.path.insert(0, path64)
+    global _selected
+    _selected = bestMatch
+        
+
+#----------------------------------------------------------------------
+
+def checkInstalled(versions, optionsRequired=False):

     """
     Check if there is a version of wxPython installed that matches one
     of the versions given.  Returns True if so, False if not.  This
     can be used to determine if calling `select` will succeed or not.
 
     """
     Check if there is a version of wxPython installed that matches one
     of the versions given.  Returns True if so, False if not.  This
     can be used to determine if calling `select` will succeed or not.
 

-        :param version: Same as in `select`, either a string or a list
-                        of strings specifying the version(s) to check
-                        for.    
+        :param versions: Same as in `select`, either a string or a list
+            of strings specifying the version(s) to check for.
+
+        :param optionsRequired: Same as in `select`.

     """
     
     if type(versions) == str:
         versions = [versions]
     """
     
     if type(versions) == str:
         versions = [versions]

-    packages = _find_installed()
-    bestMatch = _get_best_match(packages, versions)
+    installed = _find_installed()
+    bestMatch = _get_best_match(installed, versions, optionsRequired)

     return bestMatch is not None
 
 #----------------------------------------------------------------------
     return bestMatch is not None
 
 #----------------------------------------------------------------------


@@ -145,20 +254,20 @@ def getInstalled():
     Returns a list of strings representing the installed wxPython
     versions that are found on the system.
     """
     Returns a list of strings representing the installed wxPython
     versions that are found on the system.
     """

-    packages = _find_installed()
-    return [os.path.basename(p.pathname)[3:] for p in packages]
+    installed = _find_installed()
+    return [os.path.basename(p.pathname)[3:] for p in installed]

 
 
 
 #----------------------------------------------------------------------
 # private helpers...
 
 
 
 
 #----------------------------------------------------------------------
 # private helpers...
 

-def _get_best_match(packages, versions):
+def _get_best_match(installed, versions, optionsRequired):

     bestMatch = None
     bestScore = 0
     bestMatch = None
     bestScore = 0

-    for pkg in packages:
+    for pkg in installed:

         for ver in versions:
         for ver in versions:

-            score = pkg.Score(_wxPackageInfo(ver))
+            score = pkg.Score(_wxPackageInfo(ver), optionsRequired)

             if score > bestScore:
                 bestMatch = pkg
                 bestScore = score
             if score > bestScore:
                 bestMatch = pkg
                 bestScore = score


@@ -206,6 +315,35 @@ def _find_installed(removeExisting=False):
     return installed
 
 
     return installed
 
 

+# Scan the sys.path looking for either a directory matching _pattern,
+# or a wx.pth file
+def _find_default():
+    for pth in sys.path:
+        # empty means to look in the current dir
+        if not pth:
+            pth = '.'
+
+        # skip it if it's not a package dir
+        if not os.path.isdir(pth):
+            continue
+        
+        # does it match the pattern?
+        base = os.path.basename(pth)
+        if fnmatch.fnmatchcase(base, _pattern):
+            return pth
+
+    for pth in sys.path:
+        if not pth:
+            pth = '.'
+        if not os.path.isdir(pth):
+            continue
+        if os.path.exists(os.path.join(pth, 'wx.pth')):
+            base = open(os.path.join(pth, 'wx.pth')).read()
+            return os.path.join(pth, base)
+
+    return None
+
+

 class _wxPackageInfo(object):
     def __init__(self, pathname, stripFirst=False):
         self.pathname = pathname
 class _wxPackageInfo(object):
     def __init__(self, pathname, stripFirst=False):
         self.pathname = pathname


@@ -217,28 +355,56 @@ class _wxPackageInfo(object):
         self.options = segments[1:]
 
 
         self.options = segments[1:]
 
 

-    def Score(self, other):
+    def Score(self, other, optionsRequired):

         score = 0
         
         score = 0
         

-        # whatever version components given in other must match exactly
+        # whatever number of version components given in other must
+        # match exactly

         minlen = min(len(self.version), len(other.version))
         if self.version[:minlen] != other.version[:minlen]:
             return 0        
         minlen = min(len(self.version), len(other.version))
         if self.version[:minlen] != other.version[:minlen]:
             return 0        

-        score += 1  # todo: should it be +=minlen to reward longer matches?
-        
+        score += 1
+
+        # check for matching options, if optionsRequired then the
+        # options are not optional ;-)

         for opt in other.options:
             if opt in self.options:
                 score += 1
         for opt in other.options:
             if opt in self.options:
                 score += 1

+            elif optionsRequired:
+                return 0
+            

         return score
         return score

-    

 
 

-    # TODO: factor self.options into the sort order?
+    
+    def CheckOptions(self, other, optionsRequired):
+        # if options are not required then this always succeeds
+        if not optionsRequired:
+            return True
+        # otherwise, if we have any option not present in other, then
+        # the match fails.
+        for opt in self.options:
+            if opt not in other.options:
+                return False
+        return True
+
+            
+   

     def __lt__(self, other):
     def __lt__(self, other):

-        return self.version < other.version
+        return self.version < other.version or \
+               (self.version == other.version and self.options < other.options)
+    def __le__(self, other):
+        return self.version <= other.version or \
+               (self.version == other.version and self.options <= other.options)
+    

     def __gt__(self, other):
     def __gt__(self, other):

-        return self.version > other.version
+        return self.version > other.version or \
+               (self.version == other.version and self.options > other.options)
+    def __ge__(self, other):
+        return self.version >= other.version or \
+               (self.version == other.version and self.options >= other.options)
+    

     def __eq__(self, other):
     def __eq__(self, other):

-        return self.version == other.version
+        return self.version == other.version and self.options == other.options

         
     
 
         
     
 


@@ -246,15 +412,33 @@ class _wxPackageInfo(object):
 
 if __name__ == '__main__':
     import pprint
 
 if __name__ == '__main__':
     import pprint

-    def test(version):
+
+    #ensureMinimal('2.5')
+    #pprint.pprint(sys.path)
+    #sys.exit()
+    
+    
+    def test(version, optionsRequired=False):
+        # setup
+        savepath = sys.path[:]
+
+        #test
+        select(version, optionsRequired)
+        print "Asked for %s, (%s):\t got: %s" % (version, optionsRequired, sys.path[0])
+
+        # reset
+        sys.path = savepath[:]
+        global _selected
+        _selected = None
+
+
+    def testEM(version, optionsRequired=False):

         # setup
         savepath = sys.path[:]
 
         #test
         # setup
         savepath = sys.path[:]
 
         #test

-        select(version)
-        print "Asked for %s:\t got: %s" % (version, sys.path[0])
-        #pprint.pprint(sys.path)
-        #print
+        ensureMinimal(version, optionsRequired)
+        print "EM: Asked for %s, (%s):\t got: %s" % (version, optionsRequired, sys.path[0])

 
         # reset
         sys.path = savepath[:]
 
         # reset
         sys.path = savepath[:]


@@ -263,13 +447,14 @@ if __name__ == '__main__':
         
         
     # make some test dirs
         
         
     # make some test dirs

-    names = ['wx-2.4',
-             'wx-2.5.2',
-             'wx-2.5.2.9-gtk2-unicode',
-             'wx-2.5.2.9-gtk-ansi',
-             'wx-2.5.1',
-             'wx-2.5.2.8-gtk2-unicode',
-             'wx-2.5.3']
+    names = ['wx-2.4-gtk-ansi',
+             'wx-2.5.2-gtk2-unicode',
+             'wx-2.5.3-gtk-ansi',
+             'wx-2.6-gtk2-unicode',
+             'wx-2.6-gtk2-ansi',
+             'wx-2.6-gtk-ansi',
+             'wx-2.7.1-gtk2-ansi',
+             ]

     for name in names:
         d = os.path.join('/tmp', name)
         os.mkdir(d)
     for name in names:
         d = os.path.join('/tmp', name)
         os.mkdir(d)


@@ -284,25 +469,36 @@ if __name__ == '__main__':
     print checkInstalled("2.4")
     print checkInstalled("2.5-unicode")
     print checkInstalled("2.99-bogus")
     print checkInstalled("2.4")
     print checkInstalled("2.5-unicode")
     print checkInstalled("2.99-bogus")

+    print "Current sys.path:"
+    pprint.pprint(sys.path)
+    print
+    

     test("2.4")
     test("2.5")
     test("2.5-gtk2")
     test("2.5.2")
     test("2.5-ansi")
     test("2.5-unicode")
     test("2.4")
     test("2.5")
     test("2.5-gtk2")
     test("2.5.2")
     test("2.5-ansi")
     test("2.5-unicode")

+    test("2.6")
+    test("2.6-ansi")
+    test(["2.6-unicode", "2.7-unicode"])
+    test(["2.6", "2.7"])
+    test(["2.6-unicode", "2.7-unicode"], optionsRequired=True)
+    
+    

     
     # There isn't a unicode match for this one, but it will give the best
     # available 2.4.  Should it give an error instead?  I don't think so...
     test("2.4-unicode") 
 
     # Try asking for multiple versions
     
     # There isn't a unicode match for this one, but it will give the best
     # available 2.4.  Should it give an error instead?  I don't think so...
     test("2.4-unicode") 
 
     # Try asking for multiple versions

-    test(["2.6", "2.5.3", "2.5.2-gtk2"])
+    test(["2.5.2", "2.5.3", "2.6"])

 
     try:
         # expecting an error on this one
 
     try:
         # expecting an error on this one

-        test("2.6")
+        test("2.9")

     except VersionError, e:
     except VersionError, e:

-        print "Asked for 2.6:\t got Exception:", e 
+        print "Asked for 2.9:\t got Exception:", e 

 
     # check for exception when incompatible versions are requested
     try:
 
     # check for exception when incompatible versions are requested
     try:


@@ -311,6 +507,15 @@ if __name__ == '__main__':
     except VersionError, e:
         print "Asked for incompatible versions, got Exception:", e 
 
     except VersionError, e:
         print "Asked for incompatible versions, got Exception:", e 
 

+    _EM_DEBUG=1
+    testEM("2.6")
+    testEM("2.6-unicode")
+    testEM("2.6-unicode", True)
+    try:
+        testEM("2.9")
+    except VersionError, e:
+        print "EM: Asked for 2.9:\t got Exception:", e 
+

     # cleanup
     for name in names:
         d = os.path.join('/tmp', name)
     # cleanup
     for name in names:
         d = os.path.join('/tmp', name)