Merge lp:~barry/ubuntu/natty/python-keyring/bug-686257 into lp:ubuntu/natty/python-keyring

[Barry Warsaw]

Update to latest upstream version.

[Daniel Holbach (dholbach)]

I guess the tests don't need to be installed.

review: Needs Fixing

[Barry Warsaw (barry)]

Sorry, I don't quite understand the comment. Do you mean that the tests aren't being installed or shouldn't be installed? Because I think they are installed, and I kind of think they should be. :)

There was a debate recently on one of the Python mailing lists about this (I forget which one, but probably either distutils or the testing sig) and there were definitely opinions on both sides. I'm personally of the opinion that tests should be installed, for various reasons:

* They can serve as documentation to users
* They can be run by end users to verify a package works properly
* They rarely take up much additional space
* It's usually easier to include the tests than not when they are shipped upstream as a subpackage

Others disagree and it can be decided on a case-by-case basis, but in this case, I see no harm and some potential good, so I would continue to include the tests.

[Daniel Holbach (dholbach)]

Fine with me.

review: Approve

=== added file 'CHANGES.txt'
--- CHANGES.txt	1970-01-01 00:00:00 +0000
+++ CHANGES.txt	2011-02-08 19:21:29 +0000
@@ -0,0 +1,46 @@
+-------
+CHANGES
+-------
+
+-----
+0.5.1
+-----
+
+* Remove a spurious KDE debug message when using KWallet
+
+* Fix a bug that caused an exception if the user canceled the KWallet dialog
+  (https://bitbucket.org/kang/python-keyring-lib/issue/37/user-canceling-of-kde-wallet-dialogs).
+
+---
+0.5
+---
+
+* Now using the existing Gnome and KDE python libs instead of custom C++
+  code.
+
+* Using the getpass module instead of custom code
+
+---
+0.4
+---
+
+* Fixed the setup script (some subdirs were not included in the release.)
+
+---
+0.3
+---
+
+* Fixed keyring.core when the user doesn't have a cfg, or is not
+  properly configured.
+
+* Fixed escaping issues for usernames with non-ascii characters
+
+---
+0.2
+---
+
+* Add support for Python 2.4+
+  http://bitbucket.org/kang/python-keyring-lib/issue/2
+
+* Fix the bug in KDE Kwallet extension compiling
+  http://bitbucket.org/kang/python-keyring-lib/issue/3

=== added file 'CONTRIBUTORS.txt'
--- CONTRIBUTORS.txt	1970-01-01 00:00:00 +0000
+++ CONTRIBUTORS.txt	2011-02-08 19:21:29 +0000
@@ -0,0 +1,11 @@
+------------
+Contributors
+------------
+
+* Kang Zhang
+* Tarek Ziade
+* Marcin Kasperski
+* Steve Borho
+* Michael Gruenewald
+* Jason R. Coombs
+* Benji York

=== modified file 'PKG-INFO'
--- PKG-INFO	2009-09-24 23:24:02 +0000
+++ PKG-INFO	2011-02-08 19:21:29 +0000
@@ -1,6 +1,6 @@
 Metadata-Version: 1.0
 Name: keyring
-Version: 0.2
+Version: 0.5.1
 Summary: Store and access your passwords safely.
 Home-page: http://home.python-keyring.org/
 Author: Kang Zhang
@@ -41,18 +41,18 @@
         
         Run easy_install or pip::
         
-        $ easy_install keyring
-        $ pip install keyring
+            $ easy_install keyring
+            $ pip install keyring
         
         Source installation
         ===================
         
         Download the source tarball, and uncompress it, then run the install command::
         
-        $ wget http://pypi.python.org/packages/source/k/keyring/keyring-0.2.tar.gz
-        $ tar -xzvf keyring-0.2.tar.gz
-        $ cd keyring-0.2
-        $ python setup.py install
+            $ wget http://pypi.python.org/packages/source/k/keyring/keyring-0.3.tar.gz
+            $ tar -xzvf keyring-0.3.tar.gz
+            $ cd keyring-0.3
+            $ python setup.py install
         
         
         --------------------------
@@ -96,9 +96,9 @@
         Here's a sample config file(The full demo can be accessed in the ``demo/keyring.py``):
         ::
         
-        [backend]
-        default-keyring=simplekeyring.SimpleKeyring
-        keyring-path=/home/kang/pyworkspace/python-keyring-lib/demo/
+            [backend]
+            default-keyring=simplekeyring.SimpleKeyring
+            keyring-path=/home/kang/pyworkspace/python-keyring-lib/demo/
         
         
         Write your own keyring backend
@@ -112,44 +112,44 @@
         The usage of the three functions:
         
         * ``supported(self)`` : Return if this backend is supported in current
-        environment. The returned value can be **0**, **1** , or **-1**. **0** means
-        suitable; **1** means recommended and **-1** means this backend is not
-        available for current environment.
+          environment. The returned value can be **0**, **1** , or **-1**. **0** means
+          suitable; **1** means recommended and **-1** means this backend is not
+          available for current environment.
         * ``get_password(self, service, username)`` : Return the stored password for the
-        ``username`` of the ``service``.
+          ``username`` of the ``service``.
         * ``set_password(self, service, username, password)`` : Store the ``password``
-        for ``username`` of the ``service`` in the backend.
+          for ``username`` of the ``service`` in the backend.
         
         For an instance, there's the source code of the demo mentioned above. It's a
         simple keyring which stores the password directly in memory.
         
         ::
         
-        """
-        simplekeyring.py
-        
-        A simple keyring class for the keyring_demo.py
-        
-        Created by Kang Zhang on 2009-07-12
-        """
-        from keyring.backend import KeyringBackend
-        
-        class SimpleKeyring(KeyringBackend):
-        """Simple Keyring is a keyring which can store only one
-        password in memory.
-        """
-        def __init__(self):
-        self.password = ''
-        
-        def supported(self):
-        return 0
-        
-        def get_password(self, service, username):
-        return self.password
-        
-        def set_password(self, service, username, password):
-        self.password = password
-        return 0
+            """
+            simplekeyring.py
+        
+            A simple keyring class for the keyring_demo.py
+        
+            Created by Kang Zhang on 2009-07-12
+            """
+            from keyring.backend import KeyringBackend
+        
+            class SimpleKeyring(KeyringBackend):
+                """Simple Keyring is a keyring which can store only one
+                password in memory.
+                """
+                def __init__(self):
+                    self.password = ''
+        
+                def supported(self):
+                    return 0
+        
+                def get_password(self, service, username):
+                    return self.password
+        
+                def set_password(self, service, username, password):
+                    self.password = password
+                    return 0
         
         
         Set the keyring in runtime
@@ -163,24 +163,27 @@
         ``set_keyring()``
         ::
         
-        # define a new keyring class which extends the KeyringBackend
-        import keyring.backend
-        class TestKeyring(keyring.backend.KeyringBackend):
-        """A test keyring which always outputs same password
-        """
-        def supported(self): return 0
-        def set_password(self, servicename, username, password): return 0
-        def get_password(self, servicename, username):
-        return "password from TestKeyring"
-        
-        # set the keyring for keyring lib
-        import keyring
-        keyring.set_keyring(TestKeyring())
-        
-        # invoke the keyring lib
-        if keyring.set_password("demo-service", "tarek", "passexample") == 0:
-        print "password stored successful"
-        print "password", keyring.get_password("demo-service", "tarek")
+            # define a new keyring class which extends the KeyringBackend
+            import keyring.backend
+            class TestKeyring(keyring.backend.KeyringBackend):
+                """A test keyring which always outputs same password
+                """
+                def supported(self): return 0
+                def set_password(self, servicename, username, password): return 0
+                def get_password(self, servicename, username):
+                    return "password from TestKeyring"
+        
+            # set the keyring for keyring lib
+            import keyring
+            keyring.set_keyring(TestKeyring())
+        
+            # invoke the keyring lib
+            try:
+                keyring.set_password("demo-service", "tarek", "passexample")
+                print "password stored sucessfully"
+            except keyring.backend.PasswordError:
+                print "failed to store password"
+            print "password", keyring.get_password("demo-service", "tarek")
         
         
         -----------------------------------------------
@@ -193,9 +196,9 @@
         The keyring lib has two functions:
         
         * ``get_password(service, username)`` : Returns the password stored in keyring.
-        If the password does not exist, it will return None.
+          If the password does not exist, it will return None.
         * ``set_password(service, username, password)`` : Store the password in the
-        keyring.
+          keyring.
         
         Example
         =======
@@ -205,62 +208,62 @@
         only returns true when the password equals to the username.
         ::
         
-        """
-        auth_demo.py
-        
-        Created by Kang Zhang 2009-08-14
-        """
-        
-        import keyring
-        import getpass
-        import ConfigParser
-        
-        def auth(username, password):
-        """A faked authorization function.
-        """
-        return username == password
-        
-        def main():
-        """This scrip demos how to use keyring facilite the authorization. The
-        username is stored in a config named 'auth_demo.cfg'
-        """
-        # config file init
-        config_file = 'auth_demo.cfg'
-        config = ConfigParser.SafeConfigParser({
-        'username':'',
-        })
-        config.read(config_file)
-        if not config.has_section('auth_demo_login'):
-        config.add_section('auth_demo_login')
-        
-        username = config.get('auth_demo_login','username')
-        password = None
-        if username != '':
-        password = keyring.get_password('auth_demo_login', username)
-        
-        if password == None or not auth(username, password):
-        
-        while 1:
-        username = raw_input("Username:\n")
-        password = getpass.getpass("Password:\n")
-        
-        if auth(username, password):
-        break
-        else:
-        print "Authorization failed."
-        
-        # store the username
-        config.set('auth_demo_login', 'username', username)
-        config.write(open(config_file, 'w'))
-        
-        # store the password
-        keyring.set_password('auth_demo_login', username, password)
-        
-        # the stuff that needs authorization here
-        print "Authorization successful."
-        
-        if __name__ == "__main__":
-        main()
+            """
+            auth_demo.py
+        
+            Created by Kang Zhang 2009-08-14
+            """
+        
+            import keyring
+            import getpass
+            import ConfigParser
+        
+            def auth(username, password):
+                """A faked authorization function.
+                """
+                return username == password
+        
+            def main():
+                """This scrip demos how to use keyring facilite the authorization. The
+                username is stored in a config named 'auth_demo.cfg'
+                """
+                # config file init
+                config_file = 'auth_demo.cfg'
+                config = ConfigParser.SafeConfigParser({
+                            'username':'',
+                            })
+                config.read(config_file)
+                if not config.has_section('auth_demo_login'):
+                    config.add_section('auth_demo_login')
+        
+                username = config.get('auth_demo_login','username')
+                password = None
+                if username != '':
+                    password = keyring.get_password('auth_demo_login', username)
+        
+                if password == None or not auth(username, password):
+        
+                    while 1:
+                        username = raw_input("Username:\n")
+                        password = getpass.getpass("Password:\n")
+        
+                        if auth(username, password):
+                            break
+                        else:
+                            print "Authorization failed."
+        
+                    # store the username
+                    config.set('auth_demo_login', 'username', username)
+                    config.write(open(config_file, 'w'))
+        
+                    # store the password
+                    keyring.set_password('auth_demo_login', username, password)
+        
+                # the stuff that needs authorization here
+                print "Authorization successful."
+        
+            if __name__ == "__main__":
+                main()
         
         ------------
         Get involved
@@ -284,8 +287,54 @@
         .. _this post: http://tarekziade.wordpress.com/2009/03/27/pycon-hallway-session-1-a-keyring-library-for-python/
         .. _Google Summer of Code: http://socghop.appspot.com/
         
-        * Kang Zhang
-        * Tarek Ziade
+        See CONTRIBUTORS.txt for a complete list of contributors.
+        
+        -------
+        CHANGES
+        -------
+        
+        -----
+        0.5.1
+        -----
+        
+        * Remove a spurious KDE debug message when using KWallet
+        
+        * Fix a bug that caused an exception if the user canceled the KWallet dialog
+          (https://bitbucket.org/kang/python-keyring-lib/issue/37/user-canceling-of-kde-wallet-dialogs).
+        
+        ---
+        0.5
+        ---
+        
+        * Now using the existing Gnome and KDE python libs instead of custom C++
+          code.
+        
+        * Using the getpass module instead of custom code
+        
+        ---
+        0.4
+        ---
+        
+        * Fixed the setup script (some subdirs were not included in the release.)
+        
+        ---
+        0.3
+        ---
+        
+        * Fixed keyring.core when the user doesn't have a cfg, or is not
+          properly configured.
+        
+        * Fixed escaping issues for usernames with non-ascii characters
+        
+        ---
+        0.2
+        ---
+        
+        * Add support for Python 2.4+
+          http://bitbucket.org/kang/python-keyring-lib/issue/2
+        
+        * Fix the bug in KDE Kwallet extension compiling
+          http://bitbucket.org/kang/python-keyring-lib/issue/3
         
 Keywords: keyring Keychain GnomeKeyring Kwallet password storage
 Platform: Many

=== modified file 'README.txt'
--- README.txt	2009-09-24 23:24:02 +0000
+++ README.txt	2011-02-08 19:21:29 +0000
@@ -41,9 +41,9 @@
 
 Download the source tarball, and uncompress it, then run the install command::
 
-    $ wget http://pypi.python.org/packages/source/k/keyring/keyring-0.2.tar.gz
-    $ tar -xzvf keyring-0.2.tar.gz
-    $ cd keyring-0.2
+    $ wget http://pypi.python.org/packages/source/k/keyring/keyring-0.3.tar.gz
+    $ tar -xzvf keyring-0.3.tar.gz
+    $ cd keyring-0.3
     $ python setup.py install
 
 
@@ -170,8 +170,11 @@
     keyring.set_keyring(TestKeyring())
 
     # invoke the keyring lib
-    if keyring.set_password("demo-service", "tarek", "passexample") == 0:
-        print "password stored successful"
+    try:
+        keyring.set_password("demo-service", "tarek", "passexample")
+        print "password stored sucessfully"
+    except keyring.backend.PasswordError:
+        print "failed to store password"
     print "password", keyring.get_password("demo-service", "tarek")
 
 
@@ -269,12 +272,12 @@
 Credits
 -------
 
-The project was based on Tarek Ziade's idea in `this post`_. Kang Zhang 
-initially carried it out as a `Google Summer of Code`_ project, and Tarek 
+The project was based on Tarek Ziade's idea in `this post`_. Kang Zhang
+initially carried it out as a `Google Summer of Code`_ project, and Tarek
 mentored Kang on this project.
 
 .. _this post: http://tarekziade.wordpress.com/2009/03/27/pycon-hallway-session-1-a-keyring-library-for-python/
 .. _Google Summer of Code: http://socghop.appspot.com/
 
-* Kang Zhang
-* Tarek Ziade
+See CONTRIBUTORS.txt for a complete list of contributors.
+

=== modified file 'debian/changelog'
--- debian/changelog	2010-12-03 00:11:03 +0000
+++ debian/changelog	2011-02-08 19:21:29 +0000
@@ -1,3 +1,24 @@
+python-keyring (0.5.1-0ubuntu1~ppa0) natty; urgency=low
+
+  * New upstream release.  (LP: #686257)
+  * debian/control
+      - The upstream package no longer builds extension modules for
+        keyring-gnome or keyring-kwallet, so those binary packages are deleted.
+      - Specify Python 2.6 as the minimum requirement and use
+        X-Python-Version instead of XS-Python-Version (dh_python2).
+      - Update Vcs-* headers to match what is given on the Cheeseshop page.
+      - Update Standards-Version and Depends.
+      - Suggests is no longer relevant, so it's removed.
+      - Trim Build-Depends to only what's needed now.
+  * debian/rules
+      - Update to dh_python2 build system and simplify.
+  * debian/python-keyring{,-gnome,-kwallet}.install
+      - Removed as there is now only one binary package.
+  * debian/copyright
+      - Include my name since the packaging has changed quite a bit.
+
+ -- Barry Warsaw <[e-mail]>  Wed, 02 Feb 2011 15:17:50 -0500
+
 python-keyring (0.2-3build1) natty; urgency=low
 
   * Rebuild to add support for python 2.7.

=== modified file 'debian/control'
--- debian/control	2009-10-13 22:59:53 +0000
+++ debian/control	2011-02-08 19:21:29 +0000
@@ -1,45 +1,21 @@
 Source: python-keyring
 Priority: optional
 Section: python
-XS-Python-Version: >= 2.5
-Maintainer: Carl Chenet <[e-mail]>
+X-Python-Version: >= 2.6
+Maintainer: Ubuntu Developers <[e-mail]>
+XSBC-Original-Maintainer: Carl Chenet <[e-mail]>
 Uploaders: Debian Python Modules Team <[e-mail]>
-Build-Depends: debhelper (>= 7.0.50~), python(>= 2.5), python-support, python-all-dev, pkg-config, libdbus-1-dev, libglib2.0-dev, libgnome-keyring-dev, kdelibs5-dev, kdelibs-bin, libqt4-dev
-Standards-Version: 3.8.3
-Homepage: http://pypi.python.org/pypi/keyring
-Vcs-Svn: svn://svn.debian.org/svn/python-modules/packages/python-keyring/trunk/
-Vcs-Browser: http://svn.debian.org/wsvn/python-modules/packages/python-keyring/trunk/
+Build-Depends: debhelper (>= 7.0.50~), python-setuptools, python-all
+Standards-Version: 3.9.1
+Homepage: http://home.python-keyring.org/
+Vcs-Hg: http://bitbucket.org/kang/python-keyring-lib/
+Vcs-Browser: http://bitbucket.org/kang/python-keyring-lib/
 
 Package: python-keyring
 Architecture: all
-Depends: ${python:Depends}, ${misc:Depends}, ${shlibs:Depends}
+Depends: ${python:Depends}, ${misc:Depends}
 Recommends: python-crypto
-Suggests: python-keyring-gnome (>= ${source:Version}), python-keyring-kwallet (>= ${source:Version})
 Description: store and access your passwords safely
  The Python keyring library provides an easy way to access the system
  keyring service (e.g Gnome-Keyring, KWallet) from Python.
  it can be used in any application that needs safe password storage.
- .
- This package does not provides the Gnome-Keyring or KWallet backends.
-
-Package: python-keyring-gnome
-Architecture: any
-Depends: ${python:Depends}, ${misc:Depends}, ${shlibs:Depends}, python-keyring (= ${source:Version})
-Provides: ${python:Provides} 
-Description: store and access your passwords safely - Gnome-Keyring backend
- The Python keyring library provides an easy way to access the system
- keyring service (e.g Gnome-Keyring, KWallet) from Python.
- It can be used in any application that needs safe password storage.
- .
- This package only provides the Gnome-Keyring backend.
-
-Package: python-keyring-kwallet
-Architecture: any
-Depends: ${python:Depends}, ${misc:Depends}, ${shlibs:Depends}, python-keyring (= ${source:Version})
-Provides: ${python:Provides} 
-Description: store and access your passwords safely - KWallet backend
- The Python keyring library provides an easy way to access the system
- keyring service (e.g Gnome-Keyring, KWallet) from Python.
- it can be used in any application that needs safe password storage.
- .
- This package only provides the KWallet backend.

=== modified file 'debian/copyright'
--- debian/copyright	2009-09-24 23:24:02 +0000
+++ debian/copyright	2011-02-08 19:21:29 +0000
@@ -1,5 +1,6 @@
-This package was debianized by Carl Chenet <[e-mail]> on
-Tue, 01 Sep 2009 00:22:25 +0200.
+This package was originally debianized by Carl Chenet <[e-mail]> on
+Tue, 01 Sep 2009 00:22:25 +0200.  The packaging was updated by Barry Warsaw
+<[e-mail]> on 2011-02-02.
 
 It was downloaded from http://pypi.python.org/pypi/keyring
 
@@ -278,6 +279,7 @@
 The Debian packaging is:
 
     Copyright © 2009 Carl Chenet <[e-mail]>
+    Copyright © 2011 Barry Warsaw <[e-mail]>
 
 and is licensed under the GPL version 3, 
 see `/usr/share/common-licenses/GPL-3'.

=== removed file 'debian/python-keyring-gnome.install'
--- debian/python-keyring-gnome.install	2009-09-24 23:24:02 +0000
+++ debian/python-keyring-gnome.install	1970-01-01 00:00:00 +0000
@@ -1,1 +0,0 @@
-usr/lib/python*/*-packages/gnome_keyring.so

=== removed file 'debian/python-keyring-kwallet.install'
--- debian/python-keyring-kwallet.install	2009-09-24 23:24:02 +0000
+++ debian/python-keyring-kwallet.install	1970-01-01 00:00:00 +0000
@@ -1,1 +0,0 @@
-usr/lib/python*/*-packages/kde_kwallet.so

=== removed file 'debian/python-keyring.install'
--- debian/python-keyring.install	2009-09-24 23:24:02 +0000
+++ debian/python-keyring.install	1970-01-01 00:00:00 +0000
@@ -1,2 +0,0 @@
-usr/lib/python*/*-packages/keyring/*.py
-usr/lib/python*/*-packages/keyring-*.egg-info

=== modified file 'debian/rules'
--- debian/rules	2009-10-13 22:59:53 +0000
+++ debian/rules	2011-02-08 19:21:29 +0000
@@ -1,13 +1,7 @@
 #!/usr/bin/make -f
-HOME=$(CURDIR)/debian/tmphome
 
 %:
-	dh $@
-
-override_dh_auto_clean:
-	rm -rf $(HOME)
-	dh_auto_clean
-
-override_dh_auto_build:
-	mkdir -p $(HOME)
-	dh_auto_build
+	dh $@ --with python2
+
+override_dh_installchangelogs:
+	dh_installchangelogs -k CHANGES.txt

=== modified file 'demo/keyring_demo.py'
--- demo/keyring_demo.py	2009-09-24 23:24:02 +0000
+++ demo/keyring_demo.py	2011-02-08 19:21:29 +0000
@@ -19,7 +19,7 @@
     config_file.writelines(["[backend]\n",
                   # the path for the user created keyring
                   "keyring-path= %s\n" % str(os.path.abspath(__file__))[:-16],
-                  # the name of the keyring class 
+                  # the name of the keyring class
                   "default-keyring=simplekeyring.SimpleKeyring\n" ])
     config_file.close()
 
@@ -28,14 +28,17 @@
     import keyring
 
     # invoke the keyring to store and fetch the password
-    if keyring.set_password("demo-service", "tarek", "passexample") == 0:
-        print "password stored sucessful"
+    try:
+        keyring.set_password("demo-service", "tarek", "passexample")
+        print "password stored sucessfully"
+    except keyring.backend.PasswordSetError:
+        print "failed to store password"
     print "password", keyring.get_password("demo-service", "tarek")
 
     os.remove(KEYRINGRC)
 
 def set_keyring_in_runtime():
-    """This function shows how to create a keyring manully and use it 
+    """This function shows how to create a keyring manully and use it
     in runtime
     """
 
@@ -45,22 +48,25 @@
         """A test keyring which always outputs same password
         """
         def supported(self): return 0
-        def set_password(self, servicename, username, password): return 0 
-        def get_password(self, servicename, username): 
+        def set_password(self, servicename, username, password): return 0
+        def get_password(self, servicename, username):
             return "password from TestKeyring"
-    
+
     # set the keyring for keyring lib
     import keyring
     keyring.set_keyring(TestKeyring())
 
     # invoke the keyring lib
-    if keyring.set_password("demo-service", "tarek", "passexample") == 0:
-        print "password stored successful"
+    try:
+        keyring.set_password("demo-service", "tarek", "passexample")
+        print "password stored sucessfully"
+    except keyring.backend.PasswordSetError:
+        print "failed to store password"
     print "password", keyring.get_password("demo-service", "tarek")
 
 def main():
-    """This script shows how to enable the keyring using the config 
-    file and in runtime. 
+    """This script shows how to enable the keyring using the config
+    file and in runtime.
     """
 
     load_keyring_by_config()

=== modified file 'extensions.py'
--- extensions.py	2009-09-24 23:24:02 +0000
+++ extensions.py	2011-02-08 19:21:29 +0000
@@ -4,67 +4,10 @@
 Created by Kang Zhang on 2009-08-07
 """
 
-import os
 import sys
-import commands
 
 from distutils.core import Extension
 
-def pkg_check(packages):
-    """Return false if not all packages has been installed properly.
-    """
-    status, output = commands.getstatusoutput("pkg-config --exists %s" %
-                                                    ' '.join(packages))
-    return len(output) == 0 and status == 0
-
-def pkg_config(packages):
-    """Return the config parameters for all packages
-    """
-    keywords = {}
-    flag_map = {'-I':'include_dirs', '-L':'library_dirs', '-l':'libraries'}
-
-    for token in commands.getoutput("pkg-config --libs --cflags %s" %
-                                                ' '.join(packages)).split():
-        try:
-            key = flag_map[token[:2]]
-            keywords.setdefault(key, []).append(token[2:])
-        except KeyError:
-            keywords.setdefault('extra_link_args', []).append(token)
-
-    return keywords
-
-def kde_exec(cmd, option):
-    """Execute the kde-config command and get the output dirs
-    """
-    return commands.getoutput("%s %s --expandvars" % (cmd, option)).split(':')
-
-def kde_check(cmd, headfiles):
-    includes = kde_exec(cmd, '--install include')
-    for filename in headfiles:
-        # generate all possible paths for the headfile
-        paths = [os.path.join(dir, filename) for dir in includes]
-        # check if file exists on any path
-        exists = any([ os.path.exists(path) for path in paths])
-        if not exists:
-            return False
-    return True
-
-def kde_config(cmd, keywords):
-    """Add the compile parameters for kdelibs
-    """
-
-    # KDE guys hate pkg-config, so we need due with it seperately. :-(
-    # See following link for more details
-    #       http://lists.kde.org/?t=109647896600005&r=1&w=2
-
-    keywords.setdefault('libraries', []).append('kdeui')
-
-    libs = kde_exec(cmd, '--path lib')
-    includes = kde_exec(cmd, '--install include')
-
-    keywords.setdefault('library_dirs', []).extend(libs)
-    keywords.setdefault('include_dirs', []).extend(includes)
-    return keywords
 
 def get_extensions():
     """Collect the extensions that can be installed.
@@ -82,32 +25,6 @@
                             'CoreServices'])
         exts.append(osx_keychain_module)
 
-    gnome_keyring_libs = ['dbus-1', 'glib-2.0', 'gnome-keyring-1']
-    if pkg_check(gnome_keyring_libs):
-        # gnome-keyring installed
-        gnome_keychain_module = Extension('gnome_keyring',
-                        sources = ['keyring/backends/gnome_keyring.c'],
-                        **pkg_config(gnome_keyring_libs)
-            )
-        exts.append(gnome_keychain_module)
-
-    # check for KWallet heardfiles
-    kde_kwallet_headfiles = ['kwallet.h']
-    kde_cmd = None
-    for cmd in ('kde-config','kde4-config'):
-        if kde_check(cmd, kde_kwallet_headfiles):
-            kde_cmd = cmd
-
-    # check for Kwallet related libs
-    kde_kwallet_libs = ['dbus-1', 'glib-2.0', 'QtGui']
-    if pkg_check(kde_kwallet_libs) and kde_cmd is not None:
-        # KDE Kwallet is installed.
-        kde_kwallet_module = Extension('kde_kwallet',
-                        sources = ['keyring/backends/kde_kwallet.cpp'],
-                        **kde_config(kde_cmd, pkg_config(kde_kwallet_libs))
-            )
-        exts.append(kde_kwallet_module)
-
     if platform in ['win32'] and sys.getwindowsversion()[-2] == 2:
         # windows 2k+
         win32_crypto_module = Extension('win32_crypto',

=== modified file 'keyring/__init__.py'
--- keyring/__init__.py	2009-09-24 23:24:02 +0000
+++ keyring/__init__.py	2011-02-08 19:21:29 +0000
@@ -7,3 +7,4 @@
 logger = logging.getLogger('keyring')
 
 from core import set_keyring, get_keyring, set_password, get_password
+from keyring.getpassbackend import get_password as get_pass_get_password

=== modified file 'keyring/backend.py'
--- keyring/backend.py	2009-09-24 23:24:02 +0000
+++ keyring/backend.py	2011-02-08 19:21:29 +0000
@@ -6,9 +6,10 @@
 
 import os
 import sys
-import getpass
 import ConfigParser
 
+from keyring.util.escape import escape as escape_for_ini
+
 try:
     from abc import ABCMeta, abstractmethod
 except ImportError:
@@ -19,12 +20,20 @@
     def abstractmethod(funcobj):
         return funcobj
 
+try:
+    import gnomekeyring
+except ImportError:
+    pass
 
 _KEYRING_SETTING = 'keyring-setting'
 _CRYPTED_PASSWORD = 'crypted-password'
 _BLOCK_SIZE = 32
 _PADDING = '0'
 
+class PasswordSetError(Exception):
+    """Raised when the password can't be set.
+    """
+
 class KeyringBackend(object):
     """The abstract base class of the keyring, every backend must implement
     this interface.
@@ -44,13 +53,13 @@
     def get_password(self, service, username):
         """Get password of the username for the service
         """
-        pass
+        return None
 
     @abstractmethod
     def set_password(self, service, username, password):
         """Set password for the username of the service
         """
-        return -1
+        raise PasswordSetError()
 
 class _ExtensionKeyring(KeyringBackend):
     """_ExtensionKeyring is a adaptor class for the platform related keyring
@@ -94,11 +103,13 @@
     def set_password(self, service, username, password):
         """Overide the set_password() in KeyringBackend.
         """
-        return self.keyring_impl.password_set(service, username, password)
+        try:
+            self.keyring_impl.password_set(service, username, password)
+        except OSError:
+            raise PasswordSetError()
 
 class OSXKeychain(_ExtensionKeyring):
-    """The keyring backend based on Keychain Service of the Mac OSX
-    """
+    """Mac OSX Keychain"""
     def _init_backend(self):
         """Return the handler: osx_keychain
         """
@@ -110,36 +121,100 @@
         """
         return sys.platform == 'darwin'
 
-class GnomeKeyring(_ExtensionKeyring):
-    """The keyring backend using Gnome Keyring.
-    """
-    def _init_backend(self):
-        """Return the gnome_keyring handler.
-        """
-        import gnome_keyring
-        return gnome_keyring
-
-    def _recommend(self):
-        """Recommend this keyring when Gnome is running.
-        """
-        # Gnome is running
-        return os.getenv("GNOME_DESKTOP_SESSION_ID") is not None
-
-
-class KDEKWallet(_ExtensionKeyring):
-    """The keyring backend based on KDE KWallet
-    """
-    def _init_backend(self):
-        """Return the kde_kwallet handler.
-        """
-        import kde_kwallet
-        return kde_kwallet
-
-    def _recommend(self):
-        """Recommend this keyring backend when KDE is running.
-        """
-        # KDE is running
-        return os.getenv("KDE_FULL_SESSION") == "true"
+class GnomeKeyring(KeyringBackend):
+    """Gnome Keyring"""
+
+    def supported(self):
+        try:
+            import gnomekeyring
+        except ImportError:
+            return -1
+        else:
+            return 1
+
+    def get_password(self, service, username):
+        """Get password of the username for the service
+        """
+        try:
+            items = gnomekeyring.find_network_password_sync(username, service)
+        except gnomekeyring.NoMatchError:
+            return None
+        except gnomekeyring.CancelledError:
+            # The user pressed "Cancel" when prompted to unlock their keyring.
+            return None
+
+        assert len(items) == 1, 'no more than one entry should ever match'
+        return items[0]['password']
+
+    def set_password(self, service, username, password):
+        """Set password for the username of the service
+        """
+        try:
+            gnomekeyring.set_network_password_sync(None, username, service,
+                None, None, None, None, 0, password)
+        except gnomekeyring.CancelledError:
+            # The user pressed "Cancel" when prompted to unlock their keyring.
+            raise PasswordSetError()
+
+def open_kwallet(kwallet_module=None, qt_module=None):
+    # Allow for the injection of module-like objects for testing purposes.
+    if kwallet_module is None:
+        kwallet_module = KWallet.Wallet
+    if qt_module is None:
+        qt_module = QtGui
+
+    # KDE wants us to instantiate an application object.
+    app = qt_module.QApplication([])
+    try:
+        window = QtGui.QWidget()
+        kwallet = kwallet_module.openWallet(
+            kwallet_module.NetworkWallet(),
+            window.winId(),
+            kwallet_module.Synchronous)
+        if kwallet is not None:
+            if not kwallet.hasFolder('Python'):
+                kwallet.createFolder('Python')
+            kwallet.setFolder('Python')
+    finally:
+        app.exit()
+
+
+kwallet = None
+try:
+    from PyKDE4.kdeui import KWallet
+    from PyQt4 import QtCore, QtGui
+except ImportError:
+    kwallet = None
+else:
+    kwallet = open_kwallet()
+
+
+class KDEKWallet(KeyringBackend):
+    """KDE KWallet"""
+
+    def supported(self):
+        if kwallet is None:
+            return -1
+        else:
+            return 1
+
+    def get_password(self, service, username):
+        """Get password of the username for the service
+        """
+        key = username + '@' + service
+        network = KWallet.Wallet.NetworkWallet()
+        if kwallet.keyDoesNotExist(network, 'Python', key):
+            return None
+
+        result = kwallet.readPassword(key)[1]
+        # The string will be a PyQt4.QtCore.QString, so turn it into a unicode
+        # object.
+        return unicode(result)
+
+    def set_password(self, service, username, password):
+        """Set password for the username of the service
+        """
+        kwallet.writePassword(username+'@'+service, password)
 
 class BasicFileKeyring(KeyringBackend):
     """BasicFileKeyring is a filebased implementation of keyring.
@@ -173,6 +248,9 @@
     def get_password(self, service, username):
         """Read the password from the file.
         """
+        service = escape_for_ini(service)
+        username = escape_for_ini(username)
+
         # load the passwords from the file
         config = ConfigParser.RawConfigParser()
         if os.path.exists(self.file_path):
@@ -192,6 +270,9 @@
     def set_password(self, service, username, password):
         """Write the password in the file.
         """
+        service = escape_for_ini(service)
+        username = escape_for_ini(username)
+
         # encrypt the password
         password_encrypted = self.encrypt(password)
         # load the password from the disk
@@ -208,11 +289,8 @@
         config_file = open(self.file_path,'w')
         config.write(config_file)
 
-        return 0
-
 class UncryptedFileKeyring(BasicFileKeyring):
-    """A simple filekeyring which dose not encrypt the password.
-    """
+    """Uncrypted File Keyring"""
     def filename(self):
         """Return the filename of the password file. It should be
         "keyring_pass.cfg" .
@@ -235,8 +313,7 @@
         return 0
 
 class CryptedFileKeyring(BasicFileKeyring):
-    """CryptedFileKeyring is a keyring using lib pycryto to encrypt the password
-    """
+    """PyCrypto File Keyring"""
     def __init__(self):
         super(CryptedFileKeyring, self).__init__()
         self.crypted_password = None
@@ -264,6 +341,7 @@
         password = None
         while 1:
             if not password:
+                import getpass
                 password = getpass.getpass()
                 password2 = getpass.getpass('Password (again): ')
                 if password != password2:
@@ -325,6 +403,7 @@
             self._init_file()
 
         print "Please input your password for the keyring"
+        import getpass
         password = getpass.getpass()
 
         if not self._auth(password):
@@ -352,9 +431,7 @@
 
 
 class Win32CryptoKeyring(BasicFileKeyring):
-    """Win32CryptoKeyring is a keyring which use Windows CryptAPI to encrypt
-    the user's passwords and store them in a file.
-    """
+    """Win32 Cryptography Keyring"""
     def __init__(self):
         super(Win32CryptoKeyring, self).__init__()
 
@@ -370,14 +447,15 @@
         return "wincrypto_pass.cfg"
 
     def supported(self):
-        """Recommend for all Windows is higher than Windows 2000.
+        """Recommend when other Windows backends are unavailable
         """
-        if self.crypt_handler is not None and sys.platform == 'win32':
-            major, minor, build, platform, text = sys.getwindowsversion()
-            if platform == 2:
-                # recommend for windows 2k+
-                return 1
-        return -1
+        recommended = select_windows_backend()
+        if recommended == None:
+            return -1
+        elif recommended == 'file':
+            return 1
+        else:
+            return 0
 
     def encrypt(self, password):
         """Encrypt the password using the CryptAPI.
@@ -390,6 +468,132 @@
         return self.crypt_handler.decrypt(password_encrypted)
 
 
+class WinVaultKeyring(KeyringBackend):
+    def __init__(self):
+        super(WinVaultKeyring, self).__init__()
+        try:
+            import pywintypes, win32cred
+            self.win32cred = win32cred
+            self.pywintypes = pywintypes
+        except ImportError:
+            self.win32cred = None
+    
+    def supported(self):
+        '''Default Windows backend, when it is available
+        '''
+        recommended = select_windows_backend()
+        if recommended == None:
+            return -1
+        elif recommended == 'cred':
+            return 1
+        else:
+            return 0
+    
+    def get_password(self, service, username):
+        try:
+            blob = self.win32cred.CredRead(Type=self.win32cred.CRED_TYPE_GENERIC, 
+                                           TargetName=service)['CredentialBlob']
+        except self.pywintypes.error, e:
+            if e[:2] == (1168, 'CredRead'):
+                return None
+            raise
+        return blob.decode("utf16")
+    
+    def set_password(self, service, username, password):
+        credential = dict(Type=self.win32cred.CRED_TYPE_GENERIC, 
+                          TargetName=service,
+                          UserName=username,
+                          CredentialBlob=unicode(password),
+                          Comment="Stored using python-keyring",
+                          Persist=self.win32cred.CRED_PERSIST_ENTERPRISE)
+        self.win32cred.CredWrite(credential, 0)
+
+
+class Win32CryptoRegistry(KeyringBackend):
+    """Win32CryptoRegistry is a keyring which use Windows CryptAPI to encrypt
+    the user's passwords and store them under registry keys
+    """
+    def __init__(self):
+        super(Win32CryptoRegistry, self).__init__()
+
+        try:
+            import win32_crypto
+            import _winreg
+            self.crypt_handler = win32_crypto
+        except ImportError:
+            self.crypt_handler = None
+
+    def supported(self):
+        """Return if this keyring supports current enviroment.
+        -1: not applicable
+         0: suitable
+         1: recommended
+        """
+        recommended = select_windows_backend()
+        if recommended == None:
+            return -1
+        elif recommended == 'reg':
+            return 1
+        else:
+            return 0
+
+    def get_password(self, service, username):
+        """Get password of the username for the service
+        """
+        from _winreg import HKEY_CURRENT_USER, OpenKey, QueryValueEx
+        try:
+            # fetch the password
+            key = r'Software\%s\Keyring' % service
+            hkey = OpenKey(HKEY_CURRENT_USER, key)
+            password_base64 = QueryValueEx(hkey, username)[0]
+            # decode with base64
+            password_encrypted = password_base64.decode("base64")
+            # decrypted the password
+            password = self.crypt_handler.decrypt(password_encrypted)
+        except EnvironmentError:
+            password = None
+        return password
+
+
+    def set_password(self, service, username, password):
+        """Write the password to the registry
+        """
+        # encrypt the password
+        password_encrypted = self.crypt_handler.encrypt(password)
+        # encode with base64
+        password_base64 = password_encrypted.encode("base64")
+
+        # store the password
+        from _winreg import HKEY_CURRENT_USER, CreateKey, SetValueEx, REG_SZ
+        hkey = CreateKey(HKEY_CURRENT_USER, r'Software\%s\Keyring' % service)
+        SetValueEx(hkey, username, 0, REG_SZ, password_base64)
+
+def select_windows_backend():
+    if os.name != 'nt':
+        return None
+    major, minor, build, platform, text = sys.getwindowsversion()
+    try:
+        import pywintypes, win32cred
+        if (major, minor) >= (5, 1):
+            # recommend for windows xp+
+            return 'cred'
+    except ImportError:
+        pass
+    try:
+        import win32_crypto, _winreg
+        if (major, minor) >= (5, 0):
+            # recommend for windows 2k+
+            return 'reg'
+    except ImportError:
+        pass
+    try:
+        import win32_crypto
+        return 'file'
+    except ImportError:
+        pass
+    return None
+
+
 _all_keyring = None
 
 def get_all_keyring():
@@ -399,6 +603,7 @@
     if _all_keyring is None:
         _all_keyring = [ OSXKeychain(), GnomeKeyring(), KDEKWallet(),
                          CryptedFileKeyring(), UncryptedFileKeyring(),
-                         Win32CryptoKeyring()]
+                         Win32CryptoKeyring(), Win32CryptoRegistry(),
+                         WinVaultKeyring()]
     return _all_keyring
 

=== added file 'keyring/backends/__init__.py'
--- keyring/backends/__init__.py	1970-01-01 00:00:00 +0000
+++ keyring/backends/__init__.py	2011-02-08 19:21:29 +0000
@@ -0,0 +1,1 @@
+#

=== removed file 'keyring/backends/gnome_keyring.c'
--- keyring/backends/gnome_keyring.c	2009-09-24 23:24:02 +0000
+++ keyring/backends/gnome_keyring.c	1970-01-01 00:00:00 +0000
@@ -1,111 +0,0 @@
-/*
- * Comment by Kang. This lib dose not support non_interactive mode
- */
-#include <glib.h>
-#include <dbus/dbus.h>
-#include <gnome-keyring.h>
-
-#include "Python.h"
-#include "keyring_util.h"
-
-static PyObject*
-gnome_keyring_password_get(PyObject *self, PyObject *args)
-{
-    const char *realmstring;
-    const char *username;
-    const char *password;
-
-    if (!PyArg_ParseTuple(args, "ss", &realmstring, &username)){
-        PyErr_Clear();
-        PyErr_SetString(PyExc_TypeError, 
-                "password_get() must be called as (servicename,username)");
-        return NULL;
-    }
-    if ((! dbus_bus_get(DBUS_BUS_SESSION,NULL)) || 
-            (!gnome_keyring_is_available())){
-        PyErr_Clear();
-        PyErr_SetString(PyExc_OSError, "Can's access the keyring now");
-        return NULL;
-    }
-
-    GnomeKeyringResult result;
-    GList *items;
-
-    result = gnome_keyring_find_network_password_sync(username, realmstring, 
-                                           NULL, NULL, NULL, NULL, 0, &items);
-
-    int status = 0;
-    if (result == GNOME_KEYRING_RESULT_OK){
-        if (items && items->data){
-            GnomeKeyringNetworkPasswordData *item;
-            item = (GnomeKeyringNetworkPasswordData *)items->data;
-            if (item->password){
-                size_t len = strlen(item->password);
-                password = string_dump(item->password, len);
-                status = 1;
-            }
-            gnome_keyring_network_password_list_free(items);
-    }
-    }  
-
-    if (!status){
-        PyErr_Clear();
-        PyErr_SetString(PyExc_OSError, "Can't fech password from system");
-        return NULL;
-    }
-    
-    return Py_BuildValue("s",password); 
-}
-static PyObject*
-gnome_keyring_password_set(PyObject *self, PyObject *args)
-{
-    const char *realmstring;
-    const char *username;
-    const char *password;
-
-    if (!PyArg_ParseTuple(args, "sss", &realmstring, &username, &password)){
-        PyErr_Clear();
-        PyErr_SetString(PyExc_TypeError,
-            "password_set() must be called as (servicename,username,password)");
-        return NULL;
-    }
-    if ((! dbus_bus_get(DBUS_BUS_SESSION,NULL)) || 
-            (!gnome_keyring_is_available())){
-        PyErr_Clear();
-        PyErr_SetString(PyExc_OSError,
-            "Can's access the keyring now");
-        return NULL;
-    }
-
-
-    GnomeKeyringResult result;
-    guint32 item_id;
-
-    result = gnome_keyring_set_network_password_sync(NULL, username, realmstring,
-                                     NULL, NULL, NULL, NULL, 0, password, &item_id);
-
-    return Py_BuildValue("i", (result!=GNOME_KEYRING_RESULT_OK));
-}
-
-
-static struct PyMethodDef gnome_keyring_methods[] = {
-    {"password_set", gnome_keyring_password_set, METH_VARARGS},
-    {"password_get", gnome_keyring_password_get, METH_VARARGS},
-    {} /* Sentinel */
-};
-
-static void
-init_application_name(void)
-{
-    const char *application_name = NULL; 
-    application_name = g_get_application_name();
-    if (!application_name)
-        g_set_application_name("Python");
-}
-
-PyMODINIT_FUNC
-initgnome_keyring(void)
-{
-    init_application_name();
-    Py_InitModule("gnome_keyring", gnome_keyring_methods);
-}

=== removed file 'keyring/backends/kde_kwallet.cpp'
--- keyring/backends/kde_kwallet.cpp	2009-09-24 23:24:02 +0000
+++ keyring/backends/kde_kwallet.cpp	1970-01-01 00:00:00 +0000
@@ -1,121 +0,0 @@
-#include <dbus/dbus.h>
-#include <QtCore/QCoreApplication>
-#include <QtCore/QString>
-
-#include <kwallet.h>
-
-#include "Python.h"
-#include "keyring_util.h"
-
-static PyObject *
-kde_kwallet_password_get(PyObject *self, PyObject *args)
-{
-    const char *realmstring;
-    const char *username;
-    const char *password;
-
-    if (!PyArg_ParseTuple(args, "ss", &realmstring, &username)){
-        PyErr_Clear();
-        PyErr_SetString(PyExc_TypeError,
-                        "password_get() must be called as (service,username)");
-        return NULL;
-    }
-
-    if (!dbus_bus_get(DBUS_BUS_SESSION,NULL)){
-        PyErr_Clear();
-        PyErr_SetString(PyExc_OSError,"can't get access to dbus");
-        return NULL;
-    }
-    
-    QCoreApplication *app;
-    if (!qApp) {
-        int argc = 1;
-        app = new QCoreApplication(argc, (char *[1]){ (char*) "python"});
-    }
-    QString folder = QString::fromUtf8("Python");
-    QString key = QString::fromUtf8(username) + "@" + QString::fromUtf8(realmstring);
-    QString wallet_name = KWallet::Wallet::NetworkWallet();
-    bool fetch_success = false;
-    if (!KWallet::Wallet::keyDoesNotExist(wallet_name, folder, key)){
-        KWallet::Wallet *wallet = KWallet::Wallet::openWallet(wallet_name, -1, 
-                                                KWallet::Wallet::Synchronous); 
-        if (wallet){
-            if (wallet->setFolder(folder)){
-                QString q_password;
-                if (wallet->readPassword(key, q_password) == 0){
-                    password = string_dump(q_password.toUtf8().data(), q_password.size());
-                    fetch_success = true;
-                }
-            }
-        }
-    }
-    if (!fetch_success){
-        PyErr_Clear();
-        PyErr_SetString(PyExc_OSError, "Can't access the password from the system");
-        return NULL;
-    }
-    return Py_BuildValue("s",password);
-}
-
-static PyObject *
-kde_kwallet_password_set(PyObject *self, PyObject *args)
-{
-    const char *realmstring;
-    const char *username;
-    const char *password;
-
-    if (!PyArg_ParseTuple(args,"sss", &realmstring, &username, &password)){
-        PyErr_Clear();
-        PyErr_SetString(PyExc_TypeError,
-            "password_set() must be called as (service,username,password)");
-        return NULL;
-    }
-    if (!dbus_bus_get(DBUS_BUS_SESSION,NULL)){
-        PyErr_Clear();
-        PyErr_SetString(PyExc_OSError, "can't get access to dbus");
-        return NULL;
-    }
-    QCoreApplication *app;
-    if (! qApp){
-        int argc = 1;
-        app = new QCoreApplication(argc,(char *[1]) {(char*) "Python"});
-    }
-
-    bool write_success = false;
-    QString q_password = QString::fromUtf8(password);
-    QString wallet_name = KWallet::Wallet::NetworkWallet();
-    QString folder = QString::fromUtf8("Python");
-    KWallet::Wallet *wallet = KWallet::Wallet::openWallet(wallet_name, -1, 
-                                            KWallet::Wallet::Synchronous);
-    if (wallet){
-        if (!wallet->hasFolder(folder)){
-            wallet->createFolder(folder);
-        }
-        if (wallet->setFolder(folder)){
-            QString key = QString::fromUtf8(username) + "@" + QString::fromUtf8(realmstring);
-            if (wallet->writePassword(key, q_password) == 0){
-                write_success = true;
-            }
-        }
-    }
-
-   if (!write_success){
-        PyErr_Clear();
-        PyErr_SetString(PyExc_OSError, "Can't write the password in the system");
-        return NULL;
-    }
-    return Py_BuildValue("i", write_success != true);
-}
-
-
-static struct PyMethodDef kde_kwallet_methods[] = {
-    {"password_set", kde_kwallet_password_set, METH_VARARGS},
-    {"password_get", kde_kwallet_password_get, METH_VARARGS},
-    {NULL,NULL}/* Sentinel */
-};
-
-PyMODINIT_FUNC
-initkde_kwallet(void)
-{
-    Py_InitModule("kde_kwallet", kde_kwallet_methods);
-}

=== modified file 'keyring/backends/osx_keychain.c'
--- keyring/backends/osx_keychain.c	2009-09-24 23:24:02 +0000
+++ keyring/backends/osx_keychain.c	2011-02-08 19:21:29 +0000
@@ -53,8 +53,8 @@
         PyErr_SetString(PyExc_OSError, "Can't store password in Keychain");
         return NULL;
     }
-    
-    return Py_BuildValue("i",(status != 0));
+
+    Py_RETURN_NONE;
 }
 
 

=== modified file 'keyring/core.py'
--- keyring/core.py	2009-09-24 23:24:02 +0000
+++ keyring/core.py	2011-02-08 19:21:29 +0000
@@ -7,7 +7,9 @@
 import ConfigParser
 import imp
 import sys
-import backend
+
+from keyring import logger
+from keyring import backend
 
 def set_keyring(keyring):
     """Set current keyring backend.
@@ -30,31 +32,31 @@
 def set_password(service_name, username, password):
     """Set password for the user in the spcified service
     """
-    return _keyring_backend.set_password(service_name, username, password)
+    _keyring_backend.set_password(service_name, username, password)
 
 def init_backend():
     """first try to load the keyring in the config file, if it has not
     been decleared, assign a defult keyring according to the platform.
     """
     #select a backend according to the config file
-    keyring_impl = load_config()
+    keyring = load_config()
 
     # if the user dose not specify a keyring, we apply a default one
-    if keyring_impl is None:
+    if keyring is None:
 
         keyrings = backend.get_all_keyring()
         # rank according the supported
         keyrings.sort(lambda x, y: y.supported() - x.supported())
         # get the most recommend one
-        keyring_impl = keyrings[0]
+        keyring = keyrings[0]
 
-    set_keyring(keyring_impl)
+    set_keyring(keyring)
 
 def load_config():
     """load a keyring using the config file, the config file can be
     in the current working directory, or in the user's home directory.
     """
-    keyring_impl = None
+    keyring = None
 
     # search from current working directory and the home folder
     keyring_cfg_list = [os.path.join(os.getcwd(), "keyringrc.cfg"),
@@ -71,12 +73,19 @@
         config.read(keyring_cfg)
         # load the keyring-path option
         try:
-            keyring_path = config.get("backend", "keyring-path").strip()
+            if config.has_section("backend"):
+                keyring_path = config.get("backend", "keyring-path").strip()
+            else:
+                keyring_path = None
         except ConfigParser.NoOptionError:
             keyring_path = None
+
         # load the keyring class name, and load it
         try:
-            keyring_name = config.get("backend", "default-keyring").strip()
+            if config.has_section("backend"):
+                keyring_name = config.get("backend", "default-keyring").strip()
+            else:
+                raise ConfigParser.NoOptionError('backend', 'default-keyring')
 
             def load_module(name, path):
                 """Load the specified module from the disk.
@@ -111,12 +120,12 @@
             keyring_class = keyring_name.split('.')[-1].strip()
             exec  "keyring_temp = module." + keyring_class + "() " in locals()
 
-            keyring_impl = keyring_temp
+            keyring = keyring_temp
         except (ConfigParser.NoOptionError, ImportError):
             logger.warning("Keyring Config file does not write correctly.\n" + \
                            "Config file: %s" % keyring_cfg)
 
-    return keyring_impl
+    return keyring
 
 # init the _keyring_backend
 init_backend()

=== added file 'keyring/getpassbackend.py'
--- keyring/getpassbackend.py	1970-01-01 00:00:00 +0000
+++ keyring/getpassbackend.py	2011-02-08 19:21:29 +0000
@@ -0,0 +1,13 @@
+"""Specific support for getpass."""
+import os
+import getpass
+
+from keyring.core import get_password as original_get_password
+
+get_default_user = getpass.getuser
+
+def get_password(prompt='Password: ', stream=None,
+                           service_name='Python',
+                           username=get_default_user()):
+    return original_get_password(service_name, username)
+

=== added file 'keyring/tests/__init__.py'
--- keyring/tests/__init__.py	1970-01-01 00:00:00 +0000
+++ keyring/tests/__init__.py	2011-02-08 19:21:29 +0000
@@ -0,0 +1,1 @@
+#

=== modified file 'keyring/tests/test_backend.py'
--- keyring/tests/test_backend.py	2009-09-24 23:24:02 +0000
+++ keyring/tests/test_backend.py	2011-02-08 19:21:29 +0000
@@ -15,14 +15,17 @@
 import commands
 import keyring.backend
 
+from keyring.backend import PasswordSetError
+
 ALPHABET = string.ascii_letters + string.digits
+DIFFICULT_CHARS = string.whitespace + string.punctuation
 
-def random_string(k):
+def random_string(k, source = ALPHABET):
     """Generate a random string with length <i>k</i>
     """
     result = ''
     for i in range(0, k):
-        result += random.choice(ALPHABET)
+        result += random.choice(source)
     return result
 
 def backup(file):
@@ -41,16 +44,10 @@
 
     __test__ = False
 
-    def init_keyring(self):
-        return None
-
     def setUp(self):
         self.keyring = self.init_keyring()
 
-    def test_password_set_get(self):
-        password = random_string(20)
-        username = random_string(20)
-        service = random_string(20)
+    def check_set_get(self, service, username, password):
         keyring = self.keyring
 
         if self.supported() == -1: # skip the unsupported keyring
@@ -60,13 +57,25 @@
         self.assertEqual(keyring.get_password(service, username), None)
 
         # common usage
-        self.assertEqual(keyring.set_password(service, username, password), 0)
+        keyring.set_password(service, username, password)
         self.assertEqual(keyring.get_password(service, username), password)
 
         # for the empty password
-        self.assertEqual(keyring.set_password(service, username, ""), 0)
+        keyring.set_password(service, username, "")
         self.assertEqual(keyring.get_password(service, username), "")
 
+    def test_password_set_get(self):
+        password = random_string(20)
+        username = random_string(20)
+        service = random_string(20)
+        self.check_set_get(service, username, password)
+
+    def test_difficult_chars(self):
+        password = random_string(20, DIFFICULT_CHARS)
+        username = random_string(20, DIFFICULT_CHARS)
+        service = random_string(20, DIFFICULT_CHARS)
+        self.check_set_get(service, username, password)
+
     def supported(self):
         """Return the correct value for supported.
         """
@@ -81,6 +90,7 @@
     __test__ = True
 
     def init_keyring(self):
+        print >> sys.stderr, "Testing OSXKeychain, following password prompts are for this keyring"
         return keyring.backend.OSXKeychain()
 
     def supported(self):
@@ -92,31 +102,58 @@
     __test__ = True
 
     def init_keyring(self):
+        print >> sys.stderr, "Testing GnomeKeyring, following password prompts are for this keyring"
         return keyring.backend.GnomeKeyring()
 
     def supported(self):
-        try:
-            import gnome_keyring
-        except ImportError:
-            return -1
-        if os.getenv("GNOME_DESKTOP_SESSION_ID") is not None:
-            return 1
-        return 0
+        return self.keyring.supported()
 
 class KDEKWalletTestCase(BackendBasicTestCase):
     __test__ = True
 
     def init_keyring(self):
+        print >> sys.stderr, "Testing KDEKWallet, following password prompts are for this keyring"
         return keyring.backend.KDEKWallet()
 
     def supported(self):
-        try:
-            import kde_kwallet
-        except ImportError:
-            return -1
-        if os.getenv("KDE_FULL_SESSION") == "true":
-            return 1
-        return 0
+        return self.keyring.supported()
+
+
+class UnOpenableKWallet(object):
+    """A module-like object used to test KDE wallet fall-back."""
+
+    Synchronous = None
+
+    def openWallet(self, *args):
+        return None
+
+    def NetworkWallet(self):
+        return None
+
+
+class FauxQtGui(object):
+    """A fake module-like object used in testing the open_kwallet function."""
+
+    class QApplication(object):
+        def __init__(self, *args):
+            pass
+
+        def exit(self):
+            pass
+
+
+class KDEWalletCanceledTestCase(unittest.TestCase):
+
+    def test_user_canceled(self):
+        # If the user cancels either the "enter your password to unlock the
+        # keyring" dialog or clicks "deny" on the "can this application access
+        # the wallet" dialog then openWallet() will return None.  The
+        # open_wallet() function should handle that eventuality by returning
+        # None to signify that the KWallet backend is not available.
+        self.assertEqual(
+            keyring.backend.open_kwallet(UnOpenableKWallet(), FauxQtGui()),
+            None)
+
 
 class FileKeyringTestCase(BackendBasicTestCase):
     __test__ = False
@@ -148,6 +185,7 @@
     __test__ = True
 
     def init_keyring(self):
+        print >> sys.stderr, "Testing UnecryptedFile, following password prompts are for this keyring"
         return keyring.backend.UncryptedFileKeyring()
 
     def supported(self):
@@ -157,6 +195,7 @@
     __test__ = True
 
     def init_keyring(self):
+        print >> sys.stderr, "Testing CryptedFile, following password prompts are for this keyring"
         return keyring.backend.CryptedFileKeyring()
 
     def supported(self):
@@ -171,6 +210,7 @@
     __test__ = True
 
     def init_keyring(self):
+        print >> sys.stderr, "Testing Win32, following password prompts are for this keyring"
         return keyring.backend.Win32CryptoKeyring()
 
     def supported(self):

=== modified file 'keyring/tests/test_core.py'
--- keyring/tests/test_core.py	2009-09-24 23:24:02 +0000
+++ keyring/tests/test_core.py	2011-02-08 19:21:29 +0000
@@ -3,10 +3,12 @@
 
 Created by Kang Zhang on 2009-08-09
 """
-
 import unittest
 import os
 import sys
+import tempfile
+import shutil
+
 import keyring.backend
 import keyring.core
 
@@ -36,17 +38,15 @@
     def test_set_get_password(self):
         """Test the basic function of the keyring.
         """
-        self.assertEqual(keyring.core.set_password("test", "user", "passtest"),
-                                                                            0)
+        keyring.core.set_password("test", "user", "passtest")
         self.assertEqual(keyring.core.get_password("test", "user"), "passtest")
-        
+
     def test_set_keyring_in_runtime(self):
         """Test the function of set keyring in runtime.
         """
         keyring.core.set_keyring(TestKeyring())
 
-        self.assertEqual(keyring.core.set_password("test", "user", "password"),
-                                                                             0)
+        keyring.core.set_password("test", "user", "password")
         self.assertEqual(keyring.core.get_password("test", "user"),
                                                                  PASSWORD_TEXT)
 
@@ -56,23 +56,54 @@
         # create the config file
         config_file = open(KEYRINGRC,'w')
         config_file.writelines(["[backend]\n",
-                  # the path for the user created keyring
-                  "keyring-path= %s\n" % str(os.path.abspath(__file__))[:-16],
-                  # the name of the keyring class
-                  "default-keyring=test_core.TestKeyring2\n" ])
+            # the path for the user created keyring
+            "keyring-path= %s\n" % os.path.dirname(os.path.abspath(__file__)),
+            # the name of the keyring class
+            "default-keyring=test_core.TestKeyring2\n" ])
         config_file.close()
 
         # init the keyring lib, the lib will automaticlly load the
         # config file and load the user defined module
         keyring.core.init_backend()
 
-        self.assertEqual(keyring.core.set_password("test", "user", "password"),
-                                                                             0)
+        keyring.core.set_password("test", "user", "password")
         self.assertEqual(keyring.core.get_password("test", "user"),
-                                                               PASSWORD_TEXT_2)
+            PASSWORD_TEXT_2)
 
         os.remove(KEYRINGRC)
 
+    def test_load_config(self):
+        tempdir = tempfile.mkdtemp()
+        old_location = os.getcwd()
+        os.chdir(tempdir)
+        personal_cfg = os.path.join(os.path.expanduser("~"), "keyringrc.cfg")
+        if os.path.exists(personal_cfg):
+            os.rename(personal_cfg, personal_cfg+'.old')
+            personal_renamed = True
+        else:
+            personal_renamed = False
+
+        # loading with an empty environment
+        keyring.core.load_config()
+
+        # loading with a file that doesn't have a backend section
+        cfg = os.path.join(tempdir, "keyringrc.cfg")
+        f = open(cfg, 'w')
+        f.write('[keyring]')
+        f.close()
+        keyring.core.load_config()
+
+        # loading with a file that doesn't have a default-keyring value
+        cfg = os.path.join(tempdir, "keyringrc.cfg")
+        f = open(cfg, 'w')
+        f.write('[backend]')
+        f.close()
+        keyring.core.load_config()
+
+        os.chdir(old_location)
+        shutil.rmtree(tempdir)
+        if personal_renamed:
+            os.rename(personal_cfg+'.old', personal_cfg)
 
 def test_suite():
     suite = unittest.TestSuite()

=== added file 'keyring/tests/test_util.py'
--- keyring/tests/test_util.py	1970-01-01 00:00:00 +0000
+++ keyring/tests/test_util.py	2011-02-08 19:21:29 +0000
@@ -0,0 +1,37 @@
+# -*- coding: utf-8 -*-
+
+"""
+Test for simple escape/unescape routine
+"""
+
+
+import unittest
+import os
+import sys
+import tempfile
+import shutil
+
+from keyring.util import escape
+
+class EscapeTestCase(unittest.TestCase):
+
+    def check_escape_unescape(self, initial):
+        escaped = escape.escape(initial)
+        self.assertTrue(all( c in (escape.LEGAL_CHARS + escape.ESCAPE_CHAR)
+                             for c in escaped))
+        unescaped = escape.unescape(escaped)
+        self.assertEqual(initial, unescaped)
+
+    def test_escape_unescape(self):
+        self.check_escape_unescape("aaaa")
+        self.check_escape_unescape("aaaa bbbb cccc")
+        self.check_escape_unescape(u"Zażółć gęślą jaźń".encode("utf-8"))
+        self.check_escape_unescape("(((P{{{{'''---; ;; '\"|%^")
+
+def test_suite():
+    suite = unittest.TestSuite()
+    suite.addTest(unittest.makeSuite(EscapeTestCase))
+    return suite
+
+if __name__ == "__main__":
+    unittest.main(defaultTest="test_suite")

=== added directory 'keyring/util'
=== added file 'keyring/util/__init__.py'
=== added file 'keyring/util/escape.py'
--- keyring/util/escape.py	1970-01-01 00:00:00 +0000
+++ keyring/util/escape.py	2011-02-08 19:21:29 +0000
@@ -0,0 +1,25 @@
+"""
+escape/unescape routines available for backends which need
+alphanumeric usernames, services, or other values
+"""
+
+import string, re
+
+LEGAL_CHARS = string.letters + string.digits
+ESCAPE_CHAR = "_"
+
+def escape(value):
+    """Escapes given value so the result consists of alphanumeric chars and underscore
+    only, and alphanumeric chars are preserved"""
+    def escape_char(c, legal = LEGAL_CHARS):
+        # Single char escape. Either normal char, or _<hexcode>
+        if c in legal:
+            return c
+        else:
+            return "%s%X" % (ESCAPE_CHAR, ord(c))
+    return "".join( escape_char(c) for c in value )
+
+def unescape(value):
+    """Reverts escape"""
+    re_esc = re.compile("_([0-9A-F]{2})")
+    return re_esc.sub(lambda i: chr(int(i.group(1),16)), value)

=== modified file 'setup.py'
--- setup.py	2009-09-24 23:24:02 +0000
+++ setup.py	2011-02-08 19:21:29 +0000
@@ -12,16 +12,17 @@
 from extensions import get_extensions
 
 setup(name = 'keyring',
-      version = "0.2",
+      version = "0.5.1",
       description = "Store and access your passwords safely.",
       url = "http://home.python-keyring.org/",
       keywords = "keyring Keychain GnomeKeyring Kwallet password storage",
       maintainer = "Kang Zhang",
       maintainer_email = "[e-mail]",
       license="PSF",
-      long_description = open('README.txt').read(),
+      long_description = open('README.txt').read() + open('CHANGES.txt').read(),
       platforms = ["Many"],
-      packages = ['keyring'],
+      packages = ['keyring', 'keyring.tests', 'keyring.util',
+                  'keyring.backends'],
       ext_modules = get_extensions()
     )