Support python 3

ahupp · ahupp · commit d033eb46a8ac · 2012-11-01T22:29:26.000-07:00
- various unicode/bytes test fixes

 - resolve an (undocumented?) change in how ctypes converts unicode
   strings to char string by always using the default filesystem
   encoding.

Test Plan:
adam@gaba:~/github/python-magic$ python test.py
.....
----------------------------------------------------------------------
Ran 5 tests in 0.010s

OK
adam@gaba:~/github/python-magic$ python3 test.py
.....
----------------------------------------------------------------------
Ran 5 tests in 0.016s

OK
adam@gaba:~/github/python-magic$ ~/opt/python3.3/bin/python3 test.py
.. snip ...
----------------------------------------------------------------------
Ran 5 tests in 0.025s
diff --git a/magic.py b/magic.py
@@ -17,6 +17,7 @@
 
 """
 
+import sys
 import os.path
 import ctypes
 import ctypes.util
@@ -139,6 +140,11 @@ def errorcheck(result, func, args):
     else:
         return result
 
+def coerce_filename(filename):
+    if filename is None:
+        return None
+    return filename.encode(sys.getfilesystemencoding())
+
 magic_open = libmagic.magic_open
 magic_open.restype = magic_t
 magic_open.argtypes = [c_int]
@@ -155,11 +161,13 @@ def errorcheck(result, func, args):
 magic_errno.restype = c_int
 magic_errno.argtypes = [magic_t]
 
-magic_file = libmagic.magic_file
-magic_file.restype = c_char_p
-magic_file.argtypes = [magic_t, c_char_p]
-magic_file.errcheck = errorcheck
+_magic_file = libmagic.magic_file
+_magic_file.restype = c_char_p
+_magic_file.argtypes = [magic_t, c_char_p]
+_magic_file.errcheck = errorcheck
 
+def magic_file(cookie, filename):
+    return _magic_file(cookie, coerce_filename(filename))
 
 _magic_buffer = libmagic.magic_buffer
 _magic_buffer.restype = c_char_p
@@ -171,10 +179,13 @@ def magic_buffer(cookie, buf):
     return _magic_buffer(cookie, buf, len(buf))
 
 
-magic_load = libmagic.magic_load
-magic_load.restype = c_int
-magic_load.argtypes = [magic_t, c_char_p]
-magic_load.errcheck = errorcheck
+_magic_load = libmagic.magic_load
+_magic_load.restype = c_int
+_magic_load.argtypes = [magic_t, c_char_p]
+_magic_load.errcheck = errorcheck
+
+def magic_load(cookie, filename):
+    return _magic_load(cookie, coerce_filename(filename))
 
 magic_setflags = libmagic.magic_setflags
 magic_setflags.restype = c_int
diff --git a/test.py b/test.py
@@ -2,26 +2,28 @@
 import os.path
 import unittest
 import random
-from StringIO import StringIO
+import magic
 from os import path
-from magic import Magic, MagicException
+
 
 testfile = [
-    ("magic.pyc", "python 2.4 byte-compiled", "application/octet-stream"),
-    ("test.pdf", "PDF document, version 1.2", "application/pdf"),
-    ("test.gz", 'gzip compressed data, was "test", from Unix, last modified: '
-     'Sat Jun 28 18:32:52 2008', "application/x-gzip"),
-    ("text.txt", "ASCII text", "text/plain"),
+    ("magic.pyc", b"python 2.4 byte-compiled", b"application/octet-stream"),
+    ("test.pdf", b"PDF document, version 1.2", b"application/pdf"),
+    ("test.gz", b'gzip compressed data, was "test", from Unix, last modified: '
+     b'Sat Jun 28 18:32:52 2008', b"application/x-gzip"),
+    ("text.txt", b"ASCII text", b"text/plain"),
+    # is there no better way to encode a unicode literal across python2/3.[01]/3.3?
+    (b"\xce\xbb".decode('utf-8'), b"empty", b"application/x-empty")
     ]
 
-testFileEncoding = [('text-iso8859-1.txt', 'iso-8859-1')]
+testFileEncoding = [('text-iso8859-1.txt', b'iso-8859-1')]
 
 class TestMagic(unittest.TestCase):
 
     mime = False
     
     def setUp(self):
-        self.m = Magic(mime=self.mime)
+        self.m = magic.Magic(mime=self.mime)
 
     def testFileTypes(self):
         for filename, desc, mime in testfile:
@@ -33,30 +35,30 @@ def testFileTypes(self):
             else:
                 target = desc
                 
-            self.assertEqual(target, self.m.from_buffer(open(filename).read(1024)))
+            self.assertEqual(target, self.m.from_buffer(open(filename, 'rb').read(1024)))
             self.assertEqual(target, self.m.from_file(filename), filename)
         
 
     def testErrors(self):
         self.assertRaises(IOError, self.m.from_file, "nonexistent")
-        self.assertRaises(MagicException, Magic, magic_file="noneexistent")
+        self.assertRaises(magic.MagicException, magic.Magic, magic_file="noneexistent")
         os.environ['MAGIC'] = '/nonexistetn'
-        self.assertRaises(MagicException, Magic)
+        self.assertRaises(magic.MagicException, magic.Magic)
         del os.environ['MAGIC']
 
 class TestMagicMime(TestMagic):
     mime = True
 
 class TestMagicMimeEncoding(unittest.TestCase):
     def setUp(self):
-        self.m = Magic(mime_encoding=True)
+        self.m = magic.Magic(mime_encoding=True)
 
     def testFileEncoding(self):
         for filename, encoding in testFileEncoding:
             filename = path.join(path.dirname(__file__),
                                  "testdata",
                                  filename)
-            self.assertEqual(encoding, self.m.from_buffer(open(filename).read(1024)))
+            self.assertEqual(encoding, self.m.from_buffer(open(filename, 'rb').read(1024)))
             self.assertEqual(encoding, self.m.from_file(filename), filename)
 
 
