Merge pull request #54 from kronosapiens/master

Reorganize lib to fit distribution conventions.

.gitignore

@@ -2,4 +2,5 @@
 build
 dist
 MANIFEST
+__pycache__
 

MANIFEST.in

@@ -1 +1 @@
-include *.py AUTHORS README.rst *.h MANIFEST.in LICENSE
+include *.py AUTHORS README.rst snappy/*.h MANIFEST.in LICENSE

setup.py

@@ -34,13 +34,12 @@
 """
 
 
-snappymodule = Extension('_snappy',
+snappymodule = Extension('snappy._snappy',
                          libraries=['snappy'],
-                         sources=['snappymodule.cc', 'crc32c.c'])
+                         sources=['snappy/snappymodule.cc', 'snappy/crc32c.c'])
 
 ext_modules = [snappymodule]
 packages = ['snappy']
-package_dir = {'snappy': ''}
 install_requires = []
 
 if 'PyPy' in sys.version:
@@ -76,6 +75,5 @@
                  ],
     ext_modules = ext_modules,
     packages = packages,
-    package_dir = package_dir,
     install_requires = install_requires
 )

snappy/__init__.py

@@ -0,0 +1,11 @@
+from snappy import (
+	compress,
+	decompress,
+	uncompress,
+	stream_compress,
+	stream_decompress,
+	StreamCompressor,
+	StreamDecompressor,
+	UncompressError,
+	isValidCompressed,
+)

snappy/__main__.py

@@ -0,0 +1,40 @@
+from snappy import stream_compress, stream_decompress
+
+def cmdline_main():
+    """This method is what is run when invoking snappy via the commandline.
+    Try python -m snappy --help
+    """
+    import sys
+    if (len(sys.argv) < 2 or len(sys.argv) > 4 or "--help" in sys.argv or
+            "-h" in sys.argv or sys.argv[1] not in ("-c", "-d")):
+        print("Usage: python -m snappy <-c/-d> [src [dst]]")
+        print("             -c      compress")
+        print("             -d      decompress")
+        print("output is stdout if dst is omitted or '-'")
+        print("input is stdin if src and dst are omitted or src is '-'.")
+        sys.exit(1)
+
+    if len(sys.argv) >= 4 and sys.argv[3] != "-":
+        dst = open(sys.argv[3], "wb")
+    elif hasattr(sys.stdout, 'buffer'):
+        dst = sys.stdout.buffer
+    else:
+        dst = sys.stdout
+
+    if len(sys.argv) >= 3 and sys.argv[2] != "-":
+        src = open(sys.argv[2], "rb")
+    elif hasattr(sys.stdin, "buffer"):
+        src = sys.stdin.buffer
+    else:
+        src = sys.stdin
+
+    if sys.argv[1] == "-c":
+        method = stream_compress
+    else:
+        method = stream_decompress
+
+    method(src, dst)
+
+
+if __name__ == "__main__":
+    cmdline_main()

snappy.py → snappy/snappy.py

@@ -287,43 +287,3 @@ def stream_decompress(src, dst, blocksize=_STREAM_TO_STREAM_BLOCK_SIZE):
         buf = decompressor.decompress(buf)
         if buf: dst.write(buf)
     decompressor.flush()  # makes sure the stream ended well
-
-
-def cmdline_main():
-    """This method is what is run when invoking snappy via the commandline.
-    Try python -m snappy --help
-    """
-    import sys
-    if (len(sys.argv) < 2 or len(sys.argv) > 4 or "--help" in sys.argv or
-            "-h" in sys.argv or sys.argv[1] not in ("-c", "-d")):
-        print("Usage: python -m snappy <-c/-d> [src [dst]]")
-        print("             -c      compress")
-        print("             -d      decompress")
-        print("output is stdout if dst is omitted or '-'")
-        print("input is stdin if src and dst are omitted or src is '-'.")
-        sys.exit(1)
-
-    if len(sys.argv) >= 4 and sys.argv[3] != "-":
-        dst = open(sys.argv[3], "wb")
-    elif hasattr(sys.stdout, 'buffer'):
-        dst = sys.stdout.buffer
-    else:
-        dst = sys.stdout
-
-    if len(sys.argv) >= 3 and sys.argv[2] != "-":
-        src = open(sys.argv[2], "rb")
-    elif hasattr(sys.stdin, "buffer"):
-        src = sys.stdin.buffer
-    else:
-        src = sys.stdin
-
-    if sys.argv[1] == "-c":
-        method = stream_compress
-    else:
-        method = stream_decompress
-
-    method(src, dst)
-
-
-if __name__ == "__main__":
-    cmdline_main()

test_snappy.py

@@ -101,12 +101,12 @@ def test_random(self):
             data = b""
             compressed = b""
             for _ in range(random.randint(0, 3)):
-                chunk = os.urandom(random.randint(0, snappy._CHUNK_MAX * 2))
+                chunk = os.urandom(random.randint(0, snappy.snappy._CHUNK_MAX * 2))
                 data += chunk
                 compressed += compressor.add_chunk(
                         chunk, compress=random.choice([True, False, None]))
 
-            upper_bound = random.choice([256, snappy._CHUNK_MAX * 2])
+            upper_bound = random.choice([256, snappy.snappy._CHUNK_MAX * 2])
             while compressed:
                 size = random.randint(0, upper_bound)
                 chunk, compressed = compressed[:size], compressed[size:]
@@ -122,7 +122,7 @@ def test_compression(self):
         compressor = snappy.StreamCompressor()
         data = b"\0" * 50
         compressed_data = snappy.compress(data)
-        crc = struct.pack("<L", snappy._masked_crc32c(data))
+        crc = struct.pack("<L", snappy.snappy._masked_crc32c(data))
         self.assertEqual(crc, b"\x8f)H\xbd")
         self.assertEqual(len(compressed_data), 6)
         self.assertEqual(compressor.add_chunk(data, compress=True),
@@ -131,42 +131,42 @@ def test_compression(self):
 
         # test that we can add uncompressed chunks
         data = b"\x01" * 50
-        crc = struct.pack("<L", snappy._masked_crc32c(data))
+        crc = struct.pack("<L", snappy.snappy._masked_crc32c(data))
         self.assertEqual(crc, b"\xb2\x14)\x8a")
         self.assertEqual(compressor.add_chunk(data, compress=False),
                          b"\x01\x36\x00\x00" + crc + data)
 
         # test that we can add more data than will fit in one chunk
-        data = b"\x01" * (snappy._CHUNK_MAX * 2 - 5)
+        data = b"\x01" * (snappy.snappy._CHUNK_MAX * 2 - 5)
         crc1 = struct.pack("<L",
-                snappy._masked_crc32c(data[:snappy._CHUNK_MAX]))
+                snappy.snappy._masked_crc32c(data[:snappy.snappy._CHUNK_MAX]))
         self.assertEqual(crc1, b"h#6\x8e")
         crc2 = struct.pack("<L",
-                snappy._masked_crc32c(data[snappy._CHUNK_MAX:]))
+                snappy.snappy._masked_crc32c(data[snappy.snappy._CHUNK_MAX:]))
         self.assertEqual(crc2, b"q\x8foE")
         self.assertEqual(compressor.add_chunk(data, compress=False),
-                b"\x01\x04\x00\x01" + crc1 + data[:snappy._CHUNK_MAX] +
-                b"\x01\xff\xff\x00" + crc2 + data[snappy._CHUNK_MAX:])
+                b"\x01\x04\x00\x01" + crc1 + data[:snappy.snappy._CHUNK_MAX] +
+                b"\x01\xff\xff\x00" + crc2 + data[snappy.snappy._CHUNK_MAX:])
 
     def test_decompression(self):
         # test that we check for the initial stream identifier
         data = b"\x01" * 50
         self.assertRaises(snappy.UncompressError,
                 snappy.StreamDecompressor().decompress,
                     b"\x01\x36\x00\00" +
-                    struct.pack("<L", snappy._masked_crc32c(data)) + data)
+                    struct.pack("<L", snappy.snappy._masked_crc32c(data)) + data)
         self.assertEqual(
                 snappy.StreamDecompressor().decompress(
                     b"\xff\x06\x00\x00sNaPpY"
                     b"\x01\x36\x00\x00" +
-                    struct.pack("<L", snappy._masked_crc32c(data)) + data),
+                    struct.pack("<L", snappy.snappy._masked_crc32c(data)) + data),
                 data)
         decompressor = snappy.StreamDecompressor()
         decompressor.decompress(b"\xff\x06\x00\x00sNaPpY")
         self.assertEqual(
                 decompressor.copy().decompress(
                     b"\x01\x36\x00\x00" +
-                    struct.pack("<L", snappy._masked_crc32c(data)) + data),
+                    struct.pack("<L", snappy.snappy._masked_crc32c(data)) + data),
                 data)
 
         # test that we throw errors for unknown unskippable chunks
@@ -179,7 +179,7 @@ def test_decompression(self):
 
         # test that we check CRCs
         compressed_data = snappy.compress(data)
-        real_crc = struct.pack("<L", snappy._masked_crc32c(data))
+        real_crc = struct.pack("<L", snappy.snappy._masked_crc32c(data))
         fake_crc = os.urandom(4)
         self.assertRaises(snappy.UncompressError,
                 decompressor.copy().decompress,
@@ -204,7 +204,7 @@ def test_decompression(self):
                     uncompressed_data)
 
     def test_concatenation(self):
-        data1 = os.urandom(snappy._CHUNK_MAX * 2)
+        data1 = os.urandom(snappy.snappy._CHUNK_MAX * 2)
         data2 = os.urandom(4096)
         decompressor = snappy.StreamDecompressor()
         self.assertEqual(

test_snappy_cffi.py

@@ -6,14 +6,14 @@
     py3k = True
 
 def test_snappy_cffi_enum():
-    from snappy_cffi import C
+    from snappy.snappy_cffi import C
 
     assert 0 == C.SNAPPY_OK
     assert 1 == C.SNAPPY_INVALID_INPUT
     assert 2 == C.SNAPPY_BUFFER_TOO_SMALL
 
 def test_snappy_all_cffi():
-    from snappy_cffi import ffi, C
+    from snappy.snappy_cffi import ffi, C
 
     import os
     data = 'string to be compressed'