misc fixes for py3 compat

6 files changed, 73 insertions, 60 deletions

diff --git a/admin/benchmarks.py b/admin/benchmarks.py
index e1503fd..32f4533 100644
--- a/admin/benchmarks.py
+++ b/admin/benchmarks.py
@@ -23,6 +23,7 @@ try:
 except ImportError:
     PasslibPolicyWarning = None
 from passlib.utils import handlers as uh
+from passlib.utils.compat import u, print_, unicode
 # local
 __all__ = [
 ]
@@ -35,11 +36,11 @@ class BlankHandler(uh.HasRounds, uh.HasSalt, uh.GenericHandler):
 
     setting_kwds = ("rounds", "salt", "salt_size")
     name = "blank"
-    ident = u"$b$"
+    ident = u("$b$")
 
     checksum_size = 1
     min_salt_size = max_salt_size = 1
-    salt_chars = u"a"
+    salt_chars = u("a")
 
     min_rounds = 1000
     max_rounds = 3000
@@ -59,7 +60,7 @@ class BlankHandler(uh.HasRounds, uh.HasSalt, uh.GenericHandler):
 
 class AnotherHandler(BlankHandler):
     name = "another"
-    ident = u"$a$"
+    ident = u("$a$")
 
 #=============================================================================
 # crypt context tests
@@ -71,20 +72,22 @@ def setup_policy():
     cpath = os.path.abspath(os.path.join(os.path.dirname(mpath), "default.cfg"))
 
     def test_policy_creation():
-        with file(cpath, "rb") as fh:
+        with open(cpath, "rb") as fh:
             policy1 = CryptPolicy.from_string(fh.read())
     yield test_policy_creation
 
     default = _load_default_policy()
     def test_policy_composition():
-        policy2 = CryptPolicy(
-            policy=default,
+        policy2 = default.replace(
             schemes = [ "sha512_crypt", "sha256_crypt", "md5_crypt",
                         "des_crypt", "unix_fallback" ],
             deprecated = [ "des_crypt" ],
             )
     yield test_policy_composition
 
+secret = u("secret")
+other = u("other")
+
 def setup_context():
     from passlib.context import CryptContext
 
@@ -99,8 +102,6 @@ def setup_context():
     yield test_context_init
 
     ctx = test_context_init()
-    secret = u"secret"
-    other = u"other"
 #    if PasslibPolicyWarning:
 #        warnings.filterwarnings("ignore", category=PasslibPolicyWarning)
     def test_context_calls():
@@ -110,6 +111,15 @@ def setup_context():
         ctx.verify_and_update(other, hash)
     yield test_context_calls
 
+def setup_handlers():
+    from passlib.hash import md5_crypt
+    md5_crypt.set_backend("builtin")
+    def test_md5_crypt():
+        hash = md5_crypt.encrypt(secret)
+        md5_crypt.verify(secret, hash)
+        md5_crypt.verify(other, hash)
+    yield test_md5_crypt
+
 #=============================================================================
 # main
 #=============================================================================
@@ -147,7 +157,7 @@ def main(*args):
                 number *= 10
             repeat = 3
             best = min(timer.repeat(repeat, number)) / number
-            print "%30s %s" % (name, pptime(best))
+            print_("%30s %s" % (name, pptime(best)))
 
 if __name__ == "__main__":
     import sys
diff --git a/passlib/context.py b/passlib/context.py
index 8dbf3cb..97cb4cf 100644
--- a/passlib/context.py
+++ b/passlib/context.py
@@ -31,7 +31,7 @@ from passlib.registry import get_crypt_handler, _validate_handler_name
 from passlib.utils import to_bytes, to_unicode, bytes, Undef, \
                           is_crypt_handler, rng, \
                           PasslibPolicyWarning
-from passlib.utils.compat import is_mapping, iteritems, int_types, \
+from passlib.utils.compat import is_mapping, iteritems, num_types, \
                                  PY3, PY_MIN_32, unicode, bytes
 from passlib.utils.compat.aliases import SafeConfigParser, StringIO, BytesIO
 #pkg
@@ -292,7 +292,7 @@ class CryptPolicy(object):
             # XXX: type check, and accept strings for from_source ?
         parse = self._parse_option_key
         self._kwds = dict((parse(key), value) for key, value in
-                          kwds.iteritems())
+                          iteritems(kwds))
         self._compile()
 
     @staticmethod
@@ -360,9 +360,9 @@ class CryptPolicy(object):
         context_options = self._context_options = {}
         norm_scheme_option = self._normalize_scheme_option
         norm_context_option = self._normalize_context_option
-        cats = set([None])
+        cats = set()
         add_cat = cats.add
-        for (cat, scheme, key), value in source.iteritems():
+        for (cat, scheme, key), value in iteritems(source):
             add_cat(cat)
             if scheme:
                 value = norm_scheme_option(key, value)
@@ -387,7 +387,8 @@ class CryptPolicy(object):
                     context_options[key] = {cat: value}
 
         # store list of categories
-        self._categories = sorted(cats)
+        cats.discard(None)
+        self._categories = [None] + sorted(cats)
 
     @staticmethod
     def _normalize_scheme_option(key, value):
@@ -644,7 +645,7 @@ class CryptPolicy(object):
             yield format_key(None, None, "schemes"), encode_list(value)
 
         # then per-category elements
-        scheme_items = sorted(self._scheme_options.iteritems())
+        scheme_items = sorted(iteritems(self._scheme_options))
         get_option = self._get_option
         for cat in self._categories:
 
@@ -677,7 +678,7 @@ class CryptPolicy(object):
     def _escape_ini_pair(self, k, v):
         if isinstance(v, str):
             v = v.replace("%", "%%") #escape any percent signs.
-        elif isinstance(v, (int, long, float)):
+        elif isinstance(v, num_types):
             v = str(v)
         return k,v
 
@@ -964,7 +965,7 @@ class _CryptRecord(object):
     def _compile_encrypt(self, settings):
         handler = self.handler
         skeys = handler.setting_kwds
-        self._settings = dict((k,v) for k,v in settings.iteritems()
+        self._settings = dict((k,v) for k,v in iteritems(settings)
                              if k in skeys)
 
         if not (self._settings or self._has_rounds):
diff --git a/passlib/tests/test_utils.py b/passlib/tests/test_utils.py
index 70090e8..08dd321 100644
--- a/passlib/tests/test_utils.py
+++ b/passlib/tests/test_utils.py
@@ -149,7 +149,7 @@ class MiscTest(TestCase):
         orig = utils.os_crypt
         try:
             utils.os_crypt = lambda secret, hash: None
-            self.assertEqual(safe_os_crypt(u'test', u'aa'), (False,None))
+            self.assertEqual(safe_os_crypt(u('test'), u('aa')), (False,None))
         finally:
             utils.os_crypt = orig
 
@@ -247,71 +247,71 @@ class MiscTest(TestCase):
         self.assertRaises(TypeError, sp, b(''))
 
         # empty strings
-        self.assertEqual(sp(u''), u'')
-        self.assertEqual(sp(u'\u00AD'), u'')
+        self.assertEqual(sp(u('')), u(''))
+        self.assertEqual(sp(u('\u00AD')), u(''))
 
         # verify B.1 chars are stripped,
-        self.assertEqual(sp(u"$\u00AD$\u200D$"), u"$$$")
+        self.assertEqual(sp(u("$\u00AD$\u200D$")), u("$$$"))
 
         # verify C.1.2 chars are replaced with space
-        self.assertEqual(sp(u"$ $\u00A0$\u3000$"), u"$ $ $ $")
+        self.assertEqual(sp(u("$ $\u00A0$\u3000$")), u("$ $ $ $"))
 
         # verify normalization to KC
-        self.assertEqual(sp(u"a\u0300"), u"\u00E0")
-        self.assertEqual(sp(u"\u00E0"), u"\u00E0")
+        self.assertEqual(sp(u("a\u0300")), u("\u00E0"))
+        self.assertEqual(sp(u("\u00E0")), u("\u00E0"))
 
         # verify various forbidden characters
             # control chars
-        self.assertRaises(ValueError, sp, u"\u0000")
-        self.assertRaises(ValueError, sp, u"\u007F")
-        self.assertRaises(ValueError, sp, u"\u180E")
-        self.assertRaises(ValueError, sp, u"\uFFF9")
+        self.assertRaises(ValueError, sp, u("\u0000"))
+        self.assertRaises(ValueError, sp, u("\u007F"))
+        self.assertRaises(ValueError, sp, u("\u180E"))
+        self.assertRaises(ValueError, sp, u("\uFFF9"))
             # private use
-        self.assertRaises(ValueError, sp, u"\uE000")
+        self.assertRaises(ValueError, sp, u("\uE000"))
             # non-characters
-        self.assertRaises(ValueError, sp, u"\uFDD0")
+        self.assertRaises(ValueError, sp, u("\uFDD0"))
             # surrogates
-        self.assertRaises(ValueError, sp, u"\uD800")
+        self.assertRaises(ValueError, sp, u("\uD800"))
             # non-plaintext chars
-        self.assertRaises(ValueError, sp, u"\uFFFD")
+        self.assertRaises(ValueError, sp, u("\uFFFD"))
             # non-canon
-        self.assertRaises(ValueError, sp, u"\u2FF0")
+        self.assertRaises(ValueError, sp, u("\u2FF0"))
             # change display properties
-        self.assertRaises(ValueError, sp, u"\u200E")
-        self.assertRaises(ValueError, sp, u"\u206F")
+        self.assertRaises(ValueError, sp, u("\u200E"))
+        self.assertRaises(ValueError, sp, u("\u206F"))
             # unassigned code points (as of unicode 3.2)
-        self.assertRaises(ValueError, sp, u"\u0900")
-        self.assertRaises(ValueError, sp, u"\uFFF8")
+        self.assertRaises(ValueError, sp, u("\u0900"))
+        self.assertRaises(ValueError, sp, u("\uFFF8"))
 
         # verify bidi behavior
             # if starts with R/AL -- must end with R/AL
-        self.assertRaises(ValueError, sp, u"\u0627\u0031")
-        self.assertEqual(sp(u"\u0627"), u"\u0627")
-        self.assertEqual(sp(u"\u0627\u0628"), u"\u0627\u0628")
-        self.assertEqual(sp(u"\u0627\u0031\u0628"), u"\u0627\u0031\u0628")
+        self.assertRaises(ValueError, sp, u("\u0627\u0031"))
+        self.assertEqual(sp(u("\u0627")), u("\u0627"))
+        self.assertEqual(sp(u("\u0627\u0628")), u("\u0627\u0628"))
+        self.assertEqual(sp(u("\u0627\u0031\u0628")), u("\u0627\u0031\u0628"))
             # if starts with R/AL --  cannot contain L
-        self.assertRaises(ValueError, sp, u"\u0627\u0041\u0628")
+        self.assertRaises(ValueError, sp, u("\u0627\u0041\u0628"))
             # if doesn't start with R/AL -- can contain R/AL, but L & EN allowed
-        self.assertRaises(ValueError, sp, u"x\u0627z")
-        self.assertEqual(sp(u"x\u0041z"), u"x\u0041z")
+        self.assertRaises(ValueError, sp, u("x\u0627z"))
+        self.assertEqual(sp(u("x\u0041z")), u("x\u0041z"))
 
         #------------------------------------------------------
         # examples pulled from external sources, to be thorough
         #------------------------------------------------------
 
         # rfc 4031 section 3 examples
-        self.assertEqual(sp(u"I\u00ADX"), u"IX") # strip SHY
-        self.assertEqual(sp(u"user"), u"user") # unchanged
-        self.assertEqual(sp(u"USER"), u"USER") # case preserved
-        self.assertEqual(sp(u"\u00AA"), u"a") # normalize to KC form
-        self.assertEqual(sp(u"\u2168"), u"IX") # normalize to KC form
-        self.assertRaises(ValueError, sp, u"\u0007") # forbid control chars
-        self.assertRaises(ValueError, sp, u"\u0627\u0031") # invalid bidi
+        self.assertEqual(sp(u("I\u00ADX")), u("IX")) # strip SHY
+        self.assertEqual(sp(u("user")), u("user")) # unchanged
+        self.assertEqual(sp(u("USER")), u("USER")) # case preserved
+        self.assertEqual(sp(u("\u00AA")), u("a")) # normalize to KC form
+        self.assertEqual(sp(u("\u2168")), u("IX")) # normalize to KC form
+        self.assertRaises(ValueError, sp, u("\u0007")) # forbid control chars
+        self.assertRaises(ValueError, sp, u("\u0627\u0031")) # invalid bidi
 
         # rfc 3454 section 6 examples
             # starts with RAL char, must end with RAL char
-        self.assertRaises(ValueError, sp, u"\u0627\u0031")
-        self.assertEqual(sp(u"\u0627\u0031\u0628"), u"\u0627\u0031\u0628")
+        self.assertRaises(ValueError, sp, u("\u0627\u0031"))
+        self.assertEqual(sp(u("\u0627\u0031\u0628")), u("\u0627\u0031\u0628"))
 
 #=========================================================
 #byte/unicode helpers
diff --git a/passlib/tests/test_utils_handlers.py b/passlib/tests/test_utils_handlers.py
index 4ed5f06..62ac529 100644
--- a/passlib/tests/test_utils_handlers.py
+++ b/passlib/tests/test_utils_handlers.py
@@ -365,7 +365,7 @@ class PrefixWrapperTest(TestCase):
     def test_12_ident(self):
         # test ident is proxied
         h = uh.PrefixWrapper("h2", "ldap_md5", "{XXX}")
-        self.assertEqual(h.ident, u"{XXX}{MD5}")
+        self.assertEqual(h.ident, u("{XXX}{MD5}"))
         self.assertIs(h.ident_values, None)
 
         # test orig_prefix disabled ident proxy
@@ -375,7 +375,7 @@ class PrefixWrapperTest(TestCase):
 
         # test custom ident overrides default
         h = uh.PrefixWrapper("h3", "ldap_md5", "{XXX}", ident="{X")
-        self.assertEqual(h.ident, u"{X")
+        self.assertEqual(h.ident, u("{X"))
         self.assertIs(h.ident_values, None)
 
         # test custom ident must match
@@ -388,7 +388,7 @@ class PrefixWrapperTest(TestCase):
         # test ident_values is proxied
         h = uh.PrefixWrapper("h4", "bcrypt", "{XXX}")
         self.assertIs(h.ident, None)
-        self.assertEqual(h.ident_values, [ u"{XXX}$2$", u"{XXX}$2a$" ])
+        self.assertEqual(h.ident_values, [ u("{XXX}$2$"), u("{XXX}$2a$") ])
 
 #=========================================================
 #sample algorithms - these serve as known quantities
diff --git a/passlib/utils/__init__.py b/passlib/utils/__init__.py
index ec3fe25..5e182f6 100644
--- a/passlib/utils/__init__.py
+++ b/passlib/utils/__init__.py
@@ -450,8 +450,8 @@ def is_ascii_safe(source):
 #=================================================================================
 #string helpers
 #=================================================================================
-UEMPTY = u""
-USPACE = u" "
+UEMPTY = u("")
+USPACE = u(" ")
 ujoin = UEMPTY.join
 
 def consteq(left, right):
diff --git a/passlib/utils/compat.py b/passlib/utils/compat.py
index e661d13..eb4bf65 100644
--- a/passlib/utils/compat.py
+++ b/passlib/utils/compat.py
@@ -57,7 +57,7 @@ else:
     )
 
 from types import ModuleType
-class _AliasedModule(ModuleType):
+class _AliasesModule(ModuleType):
     "fake module that does lazy importing of attributes"
 
     def __init__(self, name, **source):
@@ -80,7 +80,7 @@ class _AliasedModule(ModuleType):
         attrs.update(self._source)
         return list(attrs)
 
-aliases = _AliasedModule(__name__ + ".aliases", **_aliases)
+aliases = _AliasesModule(__name__ + ".aliases", **_aliases)
 sys.modules[aliases.__name__] = aliases
 
 #=============================================================================
@@ -101,8 +101,10 @@ else:
 
 if PY3:
     int_types = (int,)
+    num_types = (int, float)
 else:
     int_types = (int, long)
+    num_types = (int, long, float)
 
 #=============================================================================
 # unicode / bytes helpers