PylibLZMA

Merge lp:~afb/pyliblzma/py2x into lp:pyliblzma

  1. py2x
  2. Merge into trunk
Proposed by Anders F Björklund
Status: Merged
Merged at revision: 496
Proposed branch: lp:~afb/pyliblzma/py2x
Merge into: lp:pyliblzma
Diff against target: 519 lines (+148/-11)
9 files modified
setup.py (+14/-7)
src/liblzma.c (+30/-0)
src/liblzma.h (+18/-0)
src/liblzma_compressobj.c (+13/-0)
src/liblzma_decompressobj.c (+15/-1)
src/liblzma_fileobj.c (+21/-0)
src/liblzma_options.c (+27/-0)
src/liblzma_util.c (+4/-0)
tests/test_liblzma.py (+6/-3)
To merge this branch: bzr merge lp:~afb/pyliblzma/py2x
Reviewer Review Type Date Requested Status
Per Øyvind Karlsen Approve
Review via email: mp+31839@code.launchpad.net

Description of the change

The branch adds backwards compatibility for python versions 2.3 through 2.6

There are NO changes for python 2.7, only fallbacks for new features missing

To post a comment you must log in.
Revision history for this message
Per Øyvind Karlsen (proyvind) wrote :

Thx!

review: Approve

Preview Diff

[H/L] Next/Prev Comment, [J/K] Next/Prev File, [N/P] Next/Prev Hunk
=== modified file 'setup.py'
--- setup.py 2010-05-27 18:48:15 +0000
+++ setup.py 2010-08-05 13:18:45 +0000
@@ -21,10 +21,18 @@
21# License along with this library; if not, write to the Free Software21# License along with this library; if not, write to the Free Software
22# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA22# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
23#23#
24import sys, os, subprocess24import sys, os
25from warnings import warn25from warnings import warn
26from setuptools import setup, Extension26from setuptools import setup, Extension
2727
28try:
29 import subprocess
30 def popen(command):
31 return subprocess.Popen(command,
32 shell=True, stdout=subprocess.PIPE, close_fds=True).stdout
33except ImportError:
34 popen = os.popen
35
28descr = "Python bindings for liblzma"36descr = "Python bindings for liblzma"
29long_descr = """PylibLZMA provides a python interface for the liblzma library37long_descr = """PylibLZMA provides a python interface for the liblzma library
30to read and write data that has been compressed or can be decompressed38to read and write data that has been compressed or can be decompressed
@@ -41,16 +49,15 @@
41warnflags = ['-Wall', '-Wextra', '-pedantic', '-Wswitch-enum', '-Wswitch-default']49warnflags = ['-Wall', '-Wextra', '-pedantic', '-Wswitch-enum', '-Wswitch-default']
42compile_args.extend(warnflags)50compile_args.extend(warnflags)
43link_args = []51link_args = []
44if not subprocess.Popen('touch gnu99-test.c; gcc -std=gnu99 -E gnu99-test.c > /dev/null; rm -f gnu99-test.c',52if not popen('touch gnu99-test.c; gcc -std=gnu99 -E gnu99-test.c 2>&1 >/dev/null; rm -f gnu99-test.c').read():
45 shell=True, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, close_fds=True).stdout.read():
46 compile_args.append('-std=gnu99')53 compile_args.append('-std=gnu99')
4754
48pc_cflags = subprocess.Popen("pkg-config --cflags liblzma", shell=True, stdout=subprocess.PIPE, close_fds=True).stdout.readline().strip()55pc_cflags = popen("pkg-config --cflags liblzma").readline().strip()
49if(pc_cflags):56if(pc_cflags):
50 compile_args.extend(pc_cflags.split(' '))57 compile_args.extend(str(pc_cflags).split(' '))
51pc_libs = subprocess.Popen("pkg-config --libs liblzma", shell=True, stdout=subprocess.PIPE, close_fds=True).stdout.readline().strip()58pc_libs = popen("pkg-config --libs liblzma").readline().strip()
52if(pc_libs):59if(pc_libs):
53 link_args.extend(pc_libs.split(b' '))60 link_args.extend(str(pc_libs).split(' '))
5461
55extens=[Extension('lzma', c_files, extra_compile_args=compile_args, extra_link_args=link_args, define_macros=version_define)]62extens=[Extension('lzma', c_files, extra_compile_args=compile_args, extra_link_args=link_args, define_macros=version_define)]
5663
5764
=== modified file 'src/liblzma.c'
--- src/liblzma.c 2010-04-13 21:05:20 +0000
+++ src/liblzma.c 2010-08-05 13:18:45 +0000
@@ -20,7 +20,9 @@
20LZMA_compress(__attribute__((unused)) PyObject *self, PyObject *args, PyObject *kwargs)20LZMA_compress(__attribute__((unused)) PyObject *self, PyObject *args, PyObject *kwargs)
21{21{
22 PyObject *ret = NULL, *options_dict = NULL;22 PyObject *ret = NULL, *options_dict = NULL;
23#if USE_PYBUFFER
23 Py_buffer pdata;24 Py_buffer pdata;
25#endif
24 uint8_t *data;26 uint8_t *data;
25 Py_ssize_t datasize, bufsize;27 Py_ssize_t datasize, bufsize;
26 lzma_ret lzuerror;28 lzma_ret lzuerror;
@@ -31,16 +33,24 @@
3133
32 static char *kwlist[] = {"input", "options", NULL};34 static char *kwlist[] = {"input", "options", NULL};
3335
36#if USE_PYBUFFER
34 if (!PyArg_ParseTupleAndKeywords(args, kwargs, "s*|O:compress", kwlist,37 if (!PyArg_ParseTupleAndKeywords(args, kwargs, "s*|O:compress", kwlist,
35 &pdata, &options_dict))38 &pdata, &options_dict))
36 return NULL;39 return NULL;
40#else
41 if (!PyArg_ParseTupleAndKeywords(args, kwargs, "s#|O:compress", kwlist,
42 (char **) &data, &datasize, &options_dict))
43 return NULL;
44#endif
3745
38 filters[0].options = &options;46 filters[0].options = &options;
39 if(!init_lzma_options("compress", options_dict, filters))47 if(!init_lzma_options("compress", options_dict, filters))
40 return NULL;48 return NULL;
4149
50#if USE_PYBUFFER
42 data = pdata.buf;51 data = pdata.buf;
43 datasize = pdata.len;52 datasize = pdata.len;
53#endif
4454
45 lzma_stream tmp = LZMA_STREAM_INIT;55 lzma_stream tmp = LZMA_STREAM_INIT;
46 *lzus = tmp;56 *lzus = tmp;
@@ -95,14 +105,18 @@
95 _PyString_Resize(&ret, (Py_ssize_t)lzus->total_out);105 _PyString_Resize(&ret, (Py_ssize_t)lzus->total_out);
96 }106 }
97107
108#if USE_PYBUFFER
98 PyBuffer_Release(&pdata);109 PyBuffer_Release(&pdata);
110#endif
99 return ret;111 return ret;
100112
101 error:113 error:
102 if(lzuerror != LZMA_MEM_ERROR && lzuerror != LZMA_PROG_ERROR)114 if(lzuerror != LZMA_MEM_ERROR && lzuerror != LZMA_PROG_ERROR)
103 lzma_end(lzus);115 lzma_end(lzus);
104 Py_XDECREF(ret);116 Py_XDECREF(ret);
117#if USE_PYBUFFER
105 PyBuffer_Release(&pdata);118 PyBuffer_Release(&pdata);
119#endif
106 return NULL;120 return NULL;
107}121}
108122
@@ -120,7 +134,9 @@
120LZMA_decompress(__attribute__((unused)) PyObject *self, PyObject *args, PyObject *kwargs)134LZMA_decompress(__attribute__((unused)) PyObject *self, PyObject *args, PyObject *kwargs)
121{135{
122 PyObject *ret = NULL;136 PyObject *ret = NULL;
137#if USE_PYBUFFER
123 Py_buffer pdata;138 Py_buffer pdata;
139#endif
124 uint8_t *data;140 uint8_t *data;
125 Py_ssize_t datasize, bufsize = SMALLCHUNK;141 Py_ssize_t datasize, bufsize = SMALLCHUNK;
126 uint64_t memlimit = -1;142 uint64_t memlimit = -1;
@@ -130,20 +146,30 @@
130146
131 static char *kwlist[] = {"input", "bufsize", "memlimit", NULL};147 static char *kwlist[] = {"input", "bufsize", "memlimit", NULL};
132148
149#if USE_PYBUFFER
133 if (!PyArg_ParseTupleAndKeywords(args, kwargs, "s*|lK:decompress", kwlist,150 if (!PyArg_ParseTupleAndKeywords(args, kwargs, "s*|lK:decompress", kwlist,
134 &pdata, &bufsize, &memlimit))151 &pdata, &bufsize, &memlimit))
135 return NULL;152 return NULL;
136 data = pdata.buf;153 data = pdata.buf;
137 datasize = pdata.len;154 datasize = pdata.len;
155#else
156 if (!PyArg_ParseTupleAndKeywords(args, kwargs, "s#|lK:decompress", kwlist,
157 (char **) &data, &datasize, &memlimit))
158 return NULL;
159#endif
138160
139 if (datasize == 0) {161 if (datasize == 0) {
162#if USE_PYBUFFER
140 PyBuffer_Release(&pdata);163 PyBuffer_Release(&pdata);
164#endif
141 return PyString_FromString("");165 return PyString_FromString("");
142 }166 }
143167
144 ret = PyString_FromStringAndSize(NULL, bufsize);168 ret = PyString_FromStringAndSize(NULL, bufsize);
145 if (!ret) {169 if (!ret) {
170#if USE_PYBUFFER
146 PyBuffer_Release(&pdata);171 PyBuffer_Release(&pdata);
172#endif
147 return NULL;173 return NULL;
148 }174 }
149175
@@ -180,7 +206,9 @@
180206
181 _PyString_Resize(&ret, (Py_ssize_t)lzus->total_out);207 _PyString_Resize(&ret, (Py_ssize_t)lzus->total_out);
182 lzma_end(lzus);208 lzma_end(lzus);
209#if USE_PYBUFFER
183 PyBuffer_Release(&pdata);210 PyBuffer_Release(&pdata);
211#endif
184212
185 return ret;213 return ret;
186 214
@@ -188,7 +216,9 @@
188 if(lzuerror != LZMA_MEM_ERROR && lzuerror != LZMA_PROG_ERROR)216 if(lzuerror != LZMA_MEM_ERROR && lzuerror != LZMA_PROG_ERROR)
189 lzma_end(lzus); 217 lzma_end(lzus);
190 Py_XDECREF(ret);218 Py_XDECREF(ret);
219#if USE_PYBUFFER
191 PyBuffer_Release(&pdata);220 PyBuffer_Release(&pdata);
221#endif
192 return NULL;222 return NULL;
193}223}
194224
195225
=== modified file 'src/liblzma.h'
--- src/liblzma.h 2010-02-20 23:08:09 +0000
+++ src/liblzma.h 2010-08-05 13:18:45 +0000
@@ -6,6 +6,24 @@
6 */6 */
7#define PY_SSIZE_T_CLEAN 17#define PY_SSIZE_T_CLEAN 1
8#include <Python.h>8#include <Python.h>
9#if PY_VERSION_HEX >= 0x020600F0
10#define USE_PYBUFFER 1
11#define USE_USECOUNT 1
12#else
13#define Py_TYPE(op) (op)->ob_type
14#define PyOS_stricmp strcasecmp
15#define USE_PYBUFFER 0
16#define USE_USECOUNT 0
17#endif
18#if PY_VERSION_HEX < 0x020500F0
19typedef int Py_ssize_t;
20#endif
21#if PY_VERSION_HEX < 0x020400F0
22#define Py_RETURN_NONE return Py_INCREF(Py_None), Py_None
23#define Py_CLEAR(op) do { if (op) { PyObject *tmp = (PyObject *)(op); \
24 (op) = NULL; Py_DECREF(tmp); } } while(0)
25#define PyDict_Contains(p, key) (PyDict_GetItem(p, key) != NULL)
26#endif
9#include <stdio.h>27#include <stdio.h>
10#include <stdlib.h>28#include <stdlib.h>
11#if defined (__APPLE__) || defined(__FreeBSD__) || \29#if defined (__APPLE__) || defined(__FreeBSD__) || \
1230
=== modified file 'src/liblzma_compressobj.c'
--- src/liblzma_compressobj.c 2010-04-13 20:26:35 +0000
+++ src/liblzma_compressobj.c 2010-08-05 13:18:45 +0000
@@ -14,7 +14,9 @@
14static PyObject *14static PyObject *
15LZMAComp_compress(LZMACompObject *self, PyObject *args)15LZMAComp_compress(LZMACompObject *self, PyObject *args)
16{16{
17#if USE_PYBUFFER
17 Py_buffer pdata;18 Py_buffer pdata;
19#endif
18 Py_ssize_t datasize, bufsize = SMALLCHUNK;20 Py_ssize_t datasize, bufsize = SMALLCHUNK;
19 uint8_t *data;21 uint8_t *data;
20 uint64_t totalout;22 uint64_t totalout;
@@ -23,10 +25,15 @@
23 lzma_ret lzuerror;25 lzma_ret lzuerror;
2426
25 INITCHECK27 INITCHECK
28#if USE_PYBUFFER
26 if (!PyArg_ParseTuple(args, "s*:compress", &pdata))29 if (!PyArg_ParseTuple(args, "s*:compress", &pdata))
27 return NULL;30 return NULL;
28 data = pdata.buf;31 data = pdata.buf;
29 datasize = pdata.len;32 datasize = pdata.len;
33#else
34 if (!PyArg_ParseTuple(args, "s#:compress", (char **) &data, &datasize))
35 return NULL;
36#endif
3037
31 ACQUIRE_LOCK(self);38 ACQUIRE_LOCK(self);
32 if (!self->running) {39 if (!self->running) {
@@ -65,12 +72,16 @@
65 _PyString_Resize(&ret, (Py_ssize_t)lzus->total_out - (Py_ssize_t)totalout);72 _PyString_Resize(&ret, (Py_ssize_t)lzus->total_out - (Py_ssize_t)totalout);
6673
67 RELEASE_LOCK(self);74 RELEASE_LOCK(self);
75#if USE_PYBUFFER
68 PyBuffer_Release(&pdata);76 PyBuffer_Release(&pdata);
77#endif
69 return ret;78 return ret;
7079
71 error:80 error:
72 RELEASE_LOCK(self);81 RELEASE_LOCK(self);
82#if USE_PYBUFFER
73 PyBuffer_Release(&pdata);83 PyBuffer_Release(&pdata);
84#endif
74 Py_XDECREF(ret);85 Py_XDECREF(ret);
75 return NULL;86 return NULL;
76}87}
@@ -364,5 +375,7 @@
364 0, /*tp_subclasses*/375 0, /*tp_subclasses*/
365 0, /*tp_weaklist*/376 0, /*tp_weaklist*/
366 0, /*tp_del*/377 0, /*tp_del*/
378#if PY_VERSION_HEX >= 0x020600F0 /* Added in version 2.6 */
367 0 /*tp_version_tag*/379 0 /*tp_version_tag*/
380#endif
368};381};
369382
=== modified file 'src/liblzma_decompressobj.c'
--- src/liblzma_decompressobj.c 2010-01-13 08:28:17 +0000
+++ src/liblzma_decompressobj.c 2010-08-05 13:18:45 +0000
@@ -16,7 +16,9 @@
16static PyObject *16static PyObject *
17LZMADecomp_decompress(LZMADecompObject *self, PyObject *args, PyObject *kwargs)17LZMADecomp_decompress(LZMADecompObject *self, PyObject *args, PyObject *kwargs)
18{18{
19#if USE_PYBUFFER
19 Py_buffer pdata;20 Py_buffer pdata;
21#endif
20 Py_ssize_t datasize, oldbufsize, bufsize = SMALLCHUNK;22 Py_ssize_t datasize, oldbufsize, bufsize = SMALLCHUNK;
21 uint8_t *data;23 uint8_t *data;
22 uint64_t start_total_out;24 uint64_t start_total_out;
@@ -26,11 +28,17 @@
26 static char *kwlist[] = {"data", "max_length", NULL};28 static char *kwlist[] = {"data", "max_length", NULL};
27 29
28 INITCHECK30 INITCHECK
31#if USE_PYBUFFER
29 if (!PyArg_ParseTupleAndKeywords(args, kwargs, "s*|l:decompress", kwlist,32 if (!PyArg_ParseTupleAndKeywords(args, kwargs, "s*|l:decompress", kwlist,
30 &pdata, &self->max_length))33 &pdata, &self->max_length))
31 return NULL;34 return NULL;
32 data = pdata.buf;35 data = pdata.buf;
33 datasize = pdata.len;36 datasize = pdata.len;
37#else
38 if (!PyArg_ParseTupleAndKeywords(args, kwargs, "s#|l:decompress", kwlist,
39 (char **) &data, &datasize, &self->max_length))
40 return NULL;
41#endif
3442
35 ACQUIRE_LOCK(self);43 ACQUIRE_LOCK(self);
36 if (!self->running) {44 if (!self->running) {
@@ -121,12 +129,16 @@
121 _PyString_Resize(&ret, (Py_ssize_t)lzus->total_out - (Py_ssize_t)start_total_out);129 _PyString_Resize(&ret, (Py_ssize_t)lzus->total_out - (Py_ssize_t)start_total_out);
122130
123 RELEASE_LOCK(self);131 RELEASE_LOCK(self);
132#if USE_PYBUFFER
124 PyBuffer_Release(&pdata);133 PyBuffer_Release(&pdata);
134#endif
125 return ret;135 return ret;
126136
127 error:137 error:
128 RELEASE_LOCK(self);138 RELEASE_LOCK(self);
139#if USE_PYBUFFER
129 PyBuffer_Release(&pdata);140 PyBuffer_Release(&pdata);
141#endif
130 Py_XDECREF(ret);142 Py_XDECREF(ret);
131 return NULL;143 return NULL;
132}144}
@@ -339,7 +351,7 @@
339 lzma_stream *lzus = &self->lzus; 351 lzma_stream *lzus = &self->lzus;
340 lzma_ret lzuerror;352 lzma_ret lzuerror;
341353
342 static char *kwlist[] = {"input", "max_length", "memlimit", NULL};354 static char *kwlist[] = {"max_length", "memlimit", NULL};
343355
344 if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|lK:LZMADecompressor", kwlist,356 if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|lK:LZMADecompressor", kwlist,
345 &self->max_length, &self->memlimit))357 &self->max_length, &self->memlimit))
@@ -434,5 +446,7 @@
434 0, /*tp_subclasses*/446 0, /*tp_subclasses*/
435 0, /*tp_weaklist*/447 0, /*tp_weaklist*/
436 0, /*tp_del*/448 0, /*tp_del*/
449#if PY_VERSION_HEX >= 0x020600F0 /* Added in version 2.6 */
437 0 /*tp_version_tag*/450 0 /*tp_version_tag*/
451#endif
438};452};
439453
=== modified file 'src/liblzma_fileobj.c'
--- src/liblzma_fileobj.c 2010-01-13 08:28:17 +0000
+++ src/liblzma_fileobj.c 2010-08-05 13:18:45 +0000
@@ -314,15 +314,22 @@
314LZMAFile_write(LZMAFileObject *self, PyObject *args)314LZMAFile_write(LZMAFileObject *self, PyObject *args)
315{315{
316 PyObject *ret = NULL;316 PyObject *ret = NULL;
317#if USE_PYBUFFER
317 Py_buffer pbuf;318 Py_buffer pbuf;
319#endif
318 char *buf;320 char *buf;
319 Py_ssize_t len;321 Py_ssize_t len;
320 lzma_ret lzuerror;322 lzma_ret lzuerror;
321323
324#if USE_PYBUFFER
322 if (!PyArg_ParseTuple(args, "s*:write", &pbuf))325 if (!PyArg_ParseTuple(args, "s*:write", &pbuf))
323 return NULL;326 return NULL;
324 buf = pbuf.buf;327 buf = pbuf.buf;
325 len = pbuf.len;328 len = pbuf.len;
329#else
330 if (!PyArg_ParseTuple(args, "s#:write", &buf, &len))
331 return NULL;
332#endif
326333
327 ACQUIRE_LOCK(self);334 ACQUIRE_LOCK(self);
328 switch (self->mode) {335 switch (self->mode) {
@@ -358,7 +365,9 @@
358 ret = Py_None;365 ret = Py_None;
359366
360cleanup:367cleanup:
368#if USE_PYBUFFER
361 PyBuffer_Release(&pbuf);369 PyBuffer_Release(&pbuf);
370#endif
362 RELEASE_LOCK(self);371 RELEASE_LOCK(self);
363 return ret;372 return ret;
364}373}
@@ -596,7 +605,9 @@
596 /* we cannot move back, so rewind the stream */605 /* we cannot move back, so rewind the stream */
597 lzma_close_real(&lzuerror, self->fp);606 lzma_close_real(&lzuerror, self->fp);
598 if (self->fp) {607 if (self->fp) {
608#if USE_USECOUNT
599 PyFile_DecUseCount((PyFileObject *)self->file);609 PyFile_DecUseCount((PyFileObject *)self->file);
610#endif
600 self->fp = NULL;611 self->fp = NULL;
601 }612 }
602 if (lzuerror != LZMA_OK) {613 if (lzuerror != LZMA_OK) {
@@ -611,8 +622,10 @@
611 self->pos = 0;622 self->pos = 0;
612 self->fp = lzma_open_real(&lzuerror, self->filters, PyFile_AsFile(self->file), self->memlimit);623 self->fp = lzma_open_real(&lzuerror, self->filters, PyFile_AsFile(self->file), self->memlimit);
613624
625#if USE_USECOUNT
614 if (self->fp)626 if (self->fp)
615 PyFile_IncUseCount((PyFileObject *)self->file);627 PyFile_IncUseCount((PyFileObject *)self->file);
628#endif
616 if (lzuerror != LZMA_OK) {629 if (lzuerror != LZMA_OK) {
617 Util_CatchLZMAError(lzuerror, &self->fp->strm, self->fp->encoding);630 Util_CatchLZMAError(lzuerror, &self->fp->strm, self->fp->encoding);
618 goto cleanup;631 goto cleanup;
@@ -704,7 +717,9 @@
704 ACQUIRE_LOCK(self);717 ACQUIRE_LOCK(self);
705 lzma_close_real(&lzuerror, self->fp);718 lzma_close_real(&lzuerror, self->fp);
706 if (self->fp) {719 if (self->fp) {
720#if USE_USECOUNT
707 PyFile_DecUseCount((PyFileObject *)self->file);721 PyFile_DecUseCount((PyFileObject *)self->file);
722#endif
708 self->fp = NULL;723 self->fp = NULL;
709 }724 }
710 self->mode = MODE_CLOSED;725 self->mode = MODE_CLOSED;
@@ -931,7 +946,9 @@
931 Util_CatchLZMAError(lzuerror, &self->fp->strm, self->fp->encoding);946 Util_CatchLZMAError(lzuerror, &self->fp->strm, self->fp->encoding);
932 goto error;947 goto error;
933 }948 }
949#if USE_USECOUNT
934 PyFile_IncUseCount((PyFileObject *)self->file);950 PyFile_IncUseCount((PyFileObject *)self->file);
951#endif
935952
936 self->mode = self->filters[0].options ? MODE_WRITE : MODE_READ;953 self->mode = self->filters[0].options ? MODE_WRITE : MODE_READ;
937954
@@ -958,7 +975,9 @@
958#endif975#endif
959 lzma_close_real(&lzuerror, self->fp);976 lzma_close_real(&lzuerror, self->fp);
960 if (self->fp) {977 if (self->fp) {
978#if USE_USECOUNT
961 PyFile_DecUseCount((PyFileObject *)self->file);979 PyFile_DecUseCount((PyFileObject *)self->file);
980#endif
962 self->fp = NULL;981 self->fp = NULL;
963 }982 }
964 Util_DropReadAhead(self);983 Util_DropReadAhead(self);
@@ -1073,5 +1092,7 @@
1073 0, /*tp_subclasses*/1092 0, /*tp_subclasses*/
1074 0, /*tp_weaklist*/1093 0, /*tp_weaklist*/
1075 0, /*tp_del*/1094 0, /*tp_del*/
1095#if PY_VERSION_HEX >= 0x020600F0 /* Added in version 2.6 */
1076 0 /*tp_version_tag*/1096 0 /*tp_version_tag*/
1097#endif
1077};1098};
10781099
=== modified file 'src/liblzma_options.c'
--- src/liblzma_options.c 2010-05-28 20:13:21 +0000
+++ src/liblzma_options.c 2010-08-05 13:18:45 +0000
@@ -246,6 +246,7 @@
246 LZMAOptionsObject *self = (LZMAOptionsObject*)PyType_GenericAlloc(type, nitems);246 LZMAOptionsObject *self = (LZMAOptionsObject*)PyType_GenericAlloc(type, nitems);
247 PyObject *levelopts, *levelString, *mf_list;247 PyObject *levelopts, *levelString, *mf_list;
248248
249#if PY_VERSION_HEX >= 0x020400F0
249 self->format = PyTuple_Pack(2, PyString_FromString("xz"), PyString_FromString("alone"));250 self->format = PyTuple_Pack(2, PyString_FromString("xz"), PyString_FromString("alone"));
250 format = self->format;251 format = self->format;
251 self->check = PyTuple_Pack(3, PyString_FromString("crc32"), PyString_FromString("crc64"),252 self->check = PyTuple_Pack(3, PyString_FromString("crc32"), PyString_FromString("crc64"),
@@ -264,6 +265,26 @@
264 self->mode_dict = PyDict_New();265 self->mode_dict = PyDict_New();
265 self->nice_len = PyTuple_Pack(2, PyInt_FromLong((ulong)LZMA_NICE_LEN_MIN),266 self->nice_len = PyTuple_Pack(2, PyInt_FromLong((ulong)LZMA_NICE_LEN_MIN),
266 PyInt_FromLong((ulong)LZMA_NICE_LEN_MAX));267 PyInt_FromLong((ulong)LZMA_NICE_LEN_MAX));
268#else
269 self->format = Py_BuildValue("(OO)", PyString_FromString("xz"), PyString_FromString("alone"));
270 format = self->format;
271 self->check = Py_BuildValue("(OOO)", PyString_FromString("crc32"), PyString_FromString("crc64"),
272 PyString_FromString("sha256"));
273 check = self->check;
274 self->level = Py_BuildValue("(OO)", PyInt_FromLong((ulong)LZMA_BEST_SPEED),
275 PyInt_FromLong((ulong)LZMA_BEST_COMPRESSION));
276 self->dict_size = Py_BuildValue("(OO)", PyInt_FromLong((ulong)LZMA_DICT_SIZE_MIN),
277 PyInt_FromLong((ulong)LZMA_DICT_SIZE_MAX));
278 self->lc = Py_BuildValue("(OO)", PyInt_FromLong((ulong)LZMA_LCLP_MIN),
279 PyInt_FromLong((ulong)LZMA_LCLP_MAX));
280 self->lp = Py_BuildValue("(OO)", PyInt_FromLong((ulong)LZMA_LCLP_MIN),
281 PyInt_FromLong((ulong)LZMA_LCLP_MAX));
282 self->pb = Py_BuildValue("(OO)", PyInt_FromLong((ulong)LZMA_PB_MIN),
283 PyInt_FromLong((ulong)LZMA_PB_MAX));
284 self->mode_dict = PyDict_New();
285 self->nice_len = Py_BuildValue("(OO)", PyInt_FromLong((ulong)LZMA_NICE_LEN_MIN),
286 PyInt_FromLong((ulong)LZMA_NICE_LEN_MAX));
287#endif
267 self->mf_dict = PyDict_New();288 self->mf_dict = PyDict_New();
268 self->depth = PyInt_FromLong(0);289 self->depth = PyInt_FromLong(0);
269290
@@ -307,7 +328,11 @@
307 lzma_lzma_preset(&options, levelNum);328 lzma_lzma_preset(&options, levelNum);
308 lzma_filter filter = { LZMA_FILTER_LZMA2, &options };329 lzma_filter filter = { LZMA_FILTER_LZMA2, &options };
309 PyObject *options_dict = LZMA_options_get(filter);330 PyObject *options_dict = LZMA_options_get(filter);
331#if PY_VERSION_HEX >= 0x020400F0
310 PyObject *settingsString = PyString_Format(levelopts, PyTuple_Pack(9,332 PyObject *settingsString = PyString_Format(levelopts, PyTuple_Pack(9,
333#else
334 PyObject *settingsString = PyString_Format(levelopts, Py_BuildValue("(OOOOOOOOO)",
335#endif
311 PyInt_FromLong(levelNum),336 PyInt_FromLong(levelNum),
312 PyDict_GetItem(options_dict, PyString_FromString("lc")),337 PyDict_GetItem(options_dict, PyString_FromString("lc")),
313 PyDict_GetItem(options_dict, PyString_FromString("lp")),338 PyDict_GetItem(options_dict, PyString_FromString("lp")),
@@ -460,5 +485,7 @@
460 0, /*tp_subclasses*/485 0, /*tp_subclasses*/
461 0, /*tp_weaklist*/486 0, /*tp_weaklist*/
462 0, /*tp_del*/487 0, /*tp_del*/
488#if PY_VERSION_HEX >= 0x020600F0 /* Added in version 2.6 */
463 0 /*tp_version_tag*/489 0 /*tp_version_tag*/
490#endif
464};491};
465492
=== modified file 'src/liblzma_util.c'
--- src/liblzma_util.c 2010-01-13 08:28:17 +0000
+++ src/liblzma_util.c 2010-08-05 13:18:45 +0000
@@ -13,7 +13,11 @@
13 break;13 break;
1414
15 case LZMA_NO_CHECK:15 case LZMA_NO_CHECK:
16#if PY_VERSION_HEX >= 0x020500F0
16 PyErr_WarnEx(LZMAError, "stream has no integrity check", 1);17 PyErr_WarnEx(LZMAError, "stream has no integrity check", 1);
18#else
19 PyErr_Warn(LZMAError, "stream has no integrity check");
20#endif
17 break;21 break;
1822
19 case LZMA_UNSUPPORTED_CHECK:23 case LZMA_UNSUPPORTED_CHECK:
2024
=== modified file 'tests/test_liblzma.py'
--- tests/test_liblzma.py 2010-04-13 20:29:41 +0000
+++ tests/test_liblzma.py 2010-08-05 13:18:45 +0000
@@ -29,7 +29,10 @@
29import os29import os
30from test.test_support import TESTFN30from test.test_support import TESTFN
3131
32from hashlib import md532try:
33 from hashlib import md5
34except ImportError:
35 from md5 import md5
33from binascii import unhexlify, hexlify36from binascii import unhexlify, hexlify
34from cStringIO import StringIO37from cStringIO import StringIO
35from StringIO import StringIO as PyStringIO38from StringIO import StringIO as PyStringIO
@@ -606,7 +609,7 @@
606 # checksum test cases609 # checksum test cases
607 def test_crc32start(self):610 def test_crc32start(self):
608 self.assertEqual(lzma.crc32(""), lzma.crc32("", 0))611 self.assertEqual(lzma.crc32(""), lzma.crc32("", 0))
609 self.assert_(lzma.crc32("abc", 0xffffffff))612 self.assert_(lzma.crc32("abc", 0xffffffffL))
610613
611 def test_crc32empty(self):614 def test_crc32empty(self):
612 self.assertEqual(lzma.crc32("", 0), 0)615 self.assertEqual(lzma.crc32("", 0), 0)
@@ -627,7 +630,7 @@
627 # These crc64 tests needs to be reviewed..630 # These crc64 tests needs to be reviewed..
628 def test_crc64start(self):631 def test_crc64start(self):
629 self.assertEqual(lzma.crc64(""), lzma.crc64("", 0))632 self.assertEqual(lzma.crc64(""), lzma.crc64("", 0))
630 self.assert_(lzma.crc64("abc", 0xffffffff))633 self.assert_(lzma.crc64("abc", 0xffffffffL))
631634
632 def test_crc64empty(self):635 def test_crc64empty(self):
633 self.assertEqual(lzma.crc64("", 0), 0)636 self.assertEqual(lzma.crc64("", 0), 0)

Subscribers

People subscribed via source and target branches