Commit 78ac43bbac7d22e89477947576e4aad653bacf80 - python-cbor

Merge tag 'upstream/0.1.24' Upstream version 0.1.24 Agustin Henze 8 years ago

9 changed file(s) with 149 addition(s) and 60 deletion(s). Raw diff Collapse all Expand all

-1

PKG-INFO less more

0	0	Metadata-Version: 1.1
1	1	Name: cbor
2		Version: 0.1.21
	2	Version: 0.1.24
3	3	Summary: RFC 7049 - Concise Binary Object Representation
4	4	Home-page: https://bitbucket.org/bodhisnarkva/cbor
5	5	Author: Brian Olson

+95

-36

c/cbormodule.c less more

27	27	#define IS_PY3 1
28	28
29	29	#endif
	30
	31	typedef struct {
	32	unsigned int sort_keys;
	33	} EncodeOptions;
30	34
31	35	// Hey Look! It's a polymorphic object structure in C!
32	36

994	998	return;
995	999	}
996	1000
997		static int inner_dumps(PyObject* ob, uint8_t* out, uintptr_t* posp);
998
999		static int dumps_dict(PyObject* ob, uint8_t* out, uintptr_t* posp) {
	1001	static int inner_dumps(EncodeOptions optp, PyObject ob, uint8_t* out, uintptr_t* posp);
	1002
	1003	static int dumps_dict(EncodeOptions optp, PyObject ob, uint8_t* out, uintptr_t* posp) {
1000	1004	uintptr_t pos = *posp;
1001		Py_ssize_t dictiter = 0;
	1005	Py_ssize_t dictlen = PyDict_Size(ob);
1002	1006	PyObject* key;
1003	1007	PyObject* val;
1004		Py_ssize_t dictlen = PyDict_Size(ob);
1005	1008	int err;
	1009
1006	1010	tag_aux_out(CBOR_MAP, dictlen, out, &pos);
1007		while (PyDict_Next(ob, &dictiter, &key, &val)) {
1008		err = inner_dumps(key, out, &pos);
1009		if (err != 0) { return err; }
1010		err = inner_dumps(val, out, &pos);
1011		if (err != 0) { return err; }
1012		}
	1011
	1012	if (optp->sort_keys) {
	1013	Py_ssize_t index = 0;
	1014	PyObject* keylist = PyDict_Keys(ob);
	1015	PyList_Sort(keylist);
	1016
	1017	//fprintf(stderr, "sortking keys\n");
	1018	for (index = 0; index < PyList_Size(keylist); index++) {
	1019	key = PyList_GetItem(keylist, index); // Borrowed ref
	1020	val = PyDict_GetItem(ob, key); // Borrowed ref
	1021	err = inner_dumps(optp, key, out, &pos);
	1022	if (err != 0) { return err; }
	1023	err = inner_dumps(optp, val, out, &pos);
	1024	if (err != 0) { return err; }
	1025	}
	1026	Py_DECREF(keylist);
	1027	} else {
	1028	Py_ssize_t dictiter = 0;
	1029	//fprintf(stderr, "unsorted keys\n");
	1030	while (PyDict_Next(ob, &dictiter, &key, &val)) {
	1031	err = inner_dumps(optp, key, out, &pos);
	1032	if (err != 0) { return err; }
	1033	err = inner_dumps(optp, val, out, &pos);
	1034	if (err != 0) { return err; }
	1035	}
	1036	}
	1037
1013	1038	*posp = pos;
1014	1039	return 0;
1015	1040	}
1016	1041
1017	1042
1018		static void dumps_bignum(uint8_t tag, PyObject* val, uint8_t* out, uintptr_t* posp) {
	1043	static void dumps_bignum(EncodeOptions optp, uint8_t tag, PyObject val, uint8_t* out, uintptr_t* posp) {
1019	1044	uintptr_t pos = (posp != NULL) ? *posp : 0;
1020	1045	PyObject* eight = PyLong_FromLong(8);
1021	1046	PyObject* bytemask = NULL;

1065	1090	*posp = pos;
1066	1091	}
1067	1092
1068		static int dumps_tag(PyObject* ob, uint8_t* out, uintptr_t* posp) {
	1093	static int dumps_tag(EncodeOptions optp, PyObject ob, uint8_t* out, uintptr_t* posp) {
1069	1094	uintptr_t pos = (posp != NULL) ? *posp : 0;
1070	1095	int err = 0;
1071	1096

1083	1108	long val = PyInt_AsLong(tag_num);
1084	1109	if (val > 0) {
1085	1110	tag_aux_out(CBOR_TAG, val, out, &pos);
1086		err = inner_dumps(tag_value, out, &pos);
	1111	err = inner_dumps(optp, tag_value, out, &pos);
1087	1112	} else {
1088	1113	PyErr_Format(PyExc_ValueError, "tag cannot be a negative int: %ld", val);
1089	1114	err = -1;

1096	1121	if (overflow == 0) {
1097	1122	if (val >= 0) {
1098	1123	tag_aux_out(CBOR_TAG, val, out, &pos);
1099		err = inner_dumps(tag_value, out, &pos);
	1124	err = inner_dumps(optp, tag_value, out, &pos);
1100	1125	} else {
1101	1126	PyErr_Format(PyExc_ValueError, "tag cannot be a negative long: %lld", val);
1102	1127	err = -1;

1125	1150
1126	1151	// With out=NULL it just counts the length.
1127	1152	// return err, 0=OK
1128		static int inner_dumps(PyObject* ob, uint8_t* out, uintptr_t* posp) {
	1153	static int inner_dumps(EncodeOptions optp, PyObject ob, uint8_t* out, uintptr_t* posp) {
1129	1154	uintptr_t pos = (posp != NULL) ? *posp : 0;
1130	1155
1131		if (PyBool_Check(ob)) {
	1156	if (ob == Py_None) {
	1157	if (out != NULL) {
	1158	out[pos] = CBOR_NULL;
	1159	}
	1160	pos += 1;
	1161	} else if (PyBool_Check(ob)) {
1132	1162	if (out != NULL) {
1133	1163	if (PyObject_IsTrue(ob)) {
1134	1164	out[pos] = CBOR_TRUE;

1137	1167	}
1138	1168	}
1139	1169	pos += 1;
1140		} else if (ob == Py_None) {
1141		if (out != NULL) {
1142		out[pos] = CBOR_NULL;
1143		}
1144		pos += 1;
1145	1170	} else if (PyDict_Check(ob)) {
1146		int err = dumps_dict(ob, out, &pos);
	1171	int err = dumps_dict(optp, ob, out, &pos);
1147	1172	if (err != 0) { return err; }
1148	1173	} else if (PyList_Check(ob)) {
1149	1174	Py_ssize_t i;
1150	1175	Py_ssize_t listlen = PyList_Size(ob);
1151	1176	tag_aux_out(CBOR_ARRAY, listlen, out, &pos);
1152	1177	for (i = 0; i < listlen; i++) {
1153		int err = inner_dumps(PyList_GetItem(ob, i), out, &pos);
	1178	int err = inner_dumps(optp, PyList_GetItem(ob, i), out, &pos);
1154	1179	if (err != 0) { return err; }
1155	1180	}
1156	1181	} else if (PyTuple_Check(ob)) {

1158	1183	Py_ssize_t listlen = PyTuple_Size(ob);
1159	1184	tag_aux_out(CBOR_ARRAY, listlen, out, &pos);
1160	1185	for (i = 0; i < listlen; i++) {
1161		int err = inner_dumps(PyTuple_GetItem(ob, i), out, &pos);
	1186	int err = inner_dumps(optp, PyTuple_GetItem(ob, i), out, &pos);
1162	1187	if (err != 0) { return err; }
1163	1188	}
1164	1189	// TODO: accept other enumerables and emit a variable length array

1187	1212	PyObject* minusone = PyLong_FromLongLong(-1L);
1188	1213	PyObject* val = PyNumber_Subtract(minusone, ob);
1189	1214	Py_DECREF(minusone);
1190		dumps_bignum(CBOR_TAG_NEGBIGNUM, val, out, &pos);
	1215	dumps_bignum(optp, CBOR_TAG_NEGBIGNUM, val, out, &pos);
1191	1216	Py_DECREF(val);
1192	1217	} else {
1193	1218	// BIG INT
1194		dumps_bignum(CBOR_TAG_BIGNUM, ob, out, &pos);
	1219	dumps_bignum(optp, CBOR_TAG_BIGNUM, ob, out, &pos);
1195	1220	}
1196	1221	}
1197	1222	} else if (PyFloat_Check(ob)) {

1218	1243	{
1219	1244	PyObject* tag_class = getCborTagClass();
1220	1245	if (PyObject_IsInstance(ob, tag_class)) {
1221		int err = dumps_tag(ob, out, &pos);
	1246	int err = dumps_tag(optp, ob, out, &pos);
1222	1247	if (err != 0) { return err; }
1223	1248	handled = 1;
1224	1249	}

1246	1271	return 0;
1247	1272	}
1248	1273
	1274	static int _dumps_kwargs(EncodeOptions optp, PyObject kwargs) {
	1275	if (kwargs == NULL) {
	1276	} else if (!PyDict_Check(kwargs)) {
	1277	PyErr_Format(PyExc_ValueError, "kwargs not dict: %R\n", kwargs);
	1278	return 0;
	1279	} else {
	1280	PyObject* sort_keys = PyDict_GetItemString(kwargs, "sort_keys"); // Borrowed ref
	1281	if (sort_keys != NULL) {
	1282	optp->sort_keys = PyObject_IsTrue(sort_keys);
	1283	//fprintf(stderr, "sort_keys=%d\n", optp->sort_keys);
	1284	}
	1285	}
	1286	return 1;
	1287	}
	1288
1249	1289	static PyObject*
1250		cbor_dumps(PyObject* noself, PyObject* args) {
	1290	cbor_dumps(PyObject* noself, PyObject* args, PyObject* kwargs) {
	1291
1251	1292	PyObject* ob;
	1293	EncodeOptions opts = {0};
	1294	EncodeOptions *optp = &opts;
1252	1295	is_big_endian();
1253	1296	if (PyType_IsSubtype(Py_TYPE(args), &PyList_Type)) {
1254	1297	ob = PyList_GetItem(args, 0);

1257	1300	} else {
1258	1301	PyErr_Format(PyExc_ValueError, "args not list or tuple: %R\n", args);
1259	1302	return NULL;
	1303	}
	1304	if (ob == NULL) {
	1305	return NULL;
	1306	}
	1307
	1308	if (!_dumps_kwargs(optp, kwargs)) {
	1309	return NULL;
1260	1310	}
1261	1311
1262	1312	{

1267	1317	int err;
1268	1318
1269	1319	// first pass just to count length
1270		err = inner_dumps(ob, NULL, &pos);
	1320	err = inner_dumps(optp, ob, NULL, &pos);
1271	1321	if (err != 0) {
1272	1322	return NULL;
1273	1323	}

1280	1330	return NULL;
1281	1331	}
1282	1332
1283		err = inner_dumps(ob, out, NULL);
	1333	err = inner_dumps(optp, ob, out, NULL);
1284	1334	if (err != 0) {
1285	1335	PyMem_Free(out);
1286	1336	return NULL;

1294	1344	}
1295	1345
1296	1346	static PyObject*
1297		cbor_dump(PyObject* noself, PyObject* args) {
	1347	cbor_dump(PyObject* noself, PyObject* args, PyObject *kwargs) {
1298	1348	// args should be (obj, fp)
1299	1349	PyObject* ob;
1300	1350	PyObject* fp;
	1351	EncodeOptions opts = {0};
	1352	EncodeOptions *optp = &opts;
1301	1353
1302	1354	is_big_endian();
1303	1355	if (PyType_IsSubtype(Py_TYPE(args), &PyList_Type)) {

1310	1362	PyErr_Format(PyExc_ValueError, "args not list or tuple: %R\n", args);
1311	1363	return NULL;
1312	1364	}
	1365	if ((ob == NULL) \|\| (fp == NULL)) {
	1366	return NULL;
	1367	}
	1368
	1369	if (!_dumps_kwargs(optp, kwargs)) {
	1370	return NULL;
	1371	}
1313	1372
1314	1373	{
1315	1374	// TODO: make this smarter, right now it is justt fp.write(dumps(ob))

1319	1378	int err;
1320	1379
1321	1380	// first pass just to count length
1322		err = inner_dumps(ob, NULL, &pos);
	1381	err = inner_dumps(optp, ob, NULL, &pos);
1323	1382	if (err != 0) {
1324	1383	return NULL;
1325	1384	}

1332	1391	return NULL;
1333	1392	}
1334	1393
1335		err = inner_dumps(ob, out, NULL);
	1394	err = inner_dumps(optp, ob, out, NULL);
1336	1395	if (err != 0) {
1337	1396	PyMem_Free(out);
1338	1397	return NULL;

1376	1435	static PyMethodDef CborMethods[] = {
1377	1436	{"loads", cbor_loads, METH_VARARGS,
1378	1437	"parse cbor from data buffer to objects"},
1379		{"dumps", cbor_dumps, METH_VARARGS,
	1438	{"dumps", (PyCFunction)cbor_dumps, METH_VARARGS\|METH_KEYWORDS,
1380	1439	"serialize python object to bytes"},
1381	1440	{"load", cbor_load, METH_VARARGS,
1382	1441	"Parse cbor from data buffer to objects.\n"
1383	1442	"Takes a file-like object capable of .read(N)\n"},
1384		{"dump", cbor_dump, METH_VARARGS,
	1443	{"dump", (PyCFunction)cbor_dump, METH_VARARGS\|METH_KEYWORDS,
1385	1444	"Serialize python object to bytes.\n"
1386	1445	"dump(obj, fp)\n"
1387	1446	"obj: object to output; fp: file-like object to .write() to\n"},

-0

cbor/VERSION.py less more

'0.1.24'

-0

cbor/__init__.py less more

8	8
9	9	from .cbor import Tag
10	10	from .tagmap import TagMapper, ClassTag, UnknownTagException
	11	from .VERSION import __doc__ as __version__
11	12
12	13	__all__ = [
13	14	'loads', 'dumps', 'load', 'dump',
14	15	'Tag',
15	16	'TagMapper', 'ClassTag', 'UnknownTagException',
	17	'__version__',
16	18	]

+30

-18

cbor/cbor.py less more

148	148	return _encode_type_num(CBOR_TEXT, len(val)) + val
149	149
150	150
151		def dumps_array(arr):
	151	def dumps_array(arr, sort_keys=False):
152	152	head = _encode_type_num(CBOR_ARRAY, len(arr))
153		parts = [dumps(x) for x in arr]
	153	parts = [dumps(x, sort_keys=sort_keys) for x in arr]
154	154	return head + b''.join(parts)
155	155
156	156
157	157	if _IS_PY3:
158		def dumps_dict(d):
	158	def dumps_dict(d, sort_keys=False):
159	159	head = _encode_type_num(CBOR_MAP, len(d))
160	160	parts = [head]
161		for k,v in d.items():
162		parts.append(dumps(k))
163		parts.append(dumps(v))
	161	if sort_keys:
	162	for k in sorted(d.keys()):
	163	v = d[k]
	164	parts.append(dumps(k, sort_keys=sort_keys))
	165	parts.append(dumps(v, sort_keys=sort_keys))
	166	else:
	167	for k,v in d.items():
	168	parts.append(dumps(k, sort_keys=sort_keys))
	169	parts.append(dumps(v, sort_keys=sort_keys))
164	170	return b''.join(parts)
165	171	else:
166		def dumps_dict(d):
	172	def dumps_dict(d, sort_keys=False):
167	173	head = _encode_type_num(CBOR_MAP, len(d))
168	174	parts = [head]
169		for k,v in d.iteritems():
170		parts.append(dumps(k))
171		parts.append(dumps(v))
	175	if sort_keys:
	176	for k in sorted(d.iterkeys()):
	177	v = d[k]
	178	parts.append(dumps(k, sort_keys=sort_keys))
	179	parts.append(dumps(v, sort_keys=sort_keys))
	180	else:
	181	for k,v in d.iteritems():
	182	parts.append(dumps(k, sort_keys=sort_keys))
	183	parts.append(dumps(v, sort_keys=sort_keys))
172	184	return b''.join(parts)
173	185
174	186

178	190	return struct.pack('B', CBOR_FALSE)
179	191
180	192
181		def dumps_tag(t):
182		return _encode_type_num(CBOR_TAG, t.tag) + dumps(t.value)
	193	def dumps_tag(t, sort_keys=False):
	194	return _encode_type_num(CBOR_TAG, t.tag) + dumps(t.value, sort_keys=sort_keys)
183	195
184	196
185	197	if _IS_PY3:

194	206	return isinstance(x, (int, long))
195	207
196	208
197		def dumps(ob):
	209	def dumps(ob, sort_keys=False):
198	210	if ob is None:
199	211	return struct.pack('B', CBOR_NULL)
200	212	if isinstance(ob, bool):

202	214	if _is_stringish(ob):
203	215	return dumps_string(ob)
204	216	if isinstance(ob, (list, tuple)):
205		return dumps_array(ob)
	217	return dumps_array(ob, sort_keys=sort_keys)
206	218	# TODO: accept other enumerables and emit a variable length array
207	219	if isinstance(ob, dict):
208		return dumps_dict(ob)
	220	return dumps_dict(ob, sort_keys=sort_keys)
209	221	if isinstance(ob, float):
210	222	return dumps_float(ob)
211	223	if _is_intish(ob):
212	224	return dumps_int(ob)
213	225	if isinstance(ob, Tag):
214		return dumps_tag(ob)
	226	return dumps_tag(ob, sort_keys=sort_keys)
215	227	raise Exception("don't know how to cbor serialize object of type %s", type(ob))
216	228
217	229
218	230	# same basic signature as json.dump, but with no options (yet)
219		def dump(obj, fp):
	231	def dump(obj, fp, sort_keys=False):
220	232	"""
221	233	obj: Python object to serialize
222	234	fp: file-like object capable of .write(bytes)
223	235	"""
224	236	# this is kinda lame, but probably not inefficient for non-huge objects
225	237	# TODO: .write() to fp as we go as each inner object is serialized
226		blob = dumps(obj)
	238	blob = dumps(obj, sort_keys=sort_keys)
227	239	fp.write(blob)
228	240
229	241

+11

-3

cbor/tagmap.py less more

4	4	# fall back to 100% python implementation
5	5	from .cbor import loads, dumps, load, dump
6	6
7		from .cbor import Tag, CBOR_TAG_CBOR
	7	from .cbor import Tag, CBOR_TAG_CBOR, _IS_PY3
8	8
9	9
10	10	class ClassTag(object):

53	53	# can't do this in Python 2.6:
54	54	#return {k:self.encode(v) for k,v in obj.iteritems()}
55	55	out = {}
56		for k,v in obj.iteritems():
	56	if _IS_PY3:
	57	items = obj.items()
	58	else:
	59	items = obj.iteritems()
	60	for k,v in items:
57	61	out[k] = self.encode(v)
58	62	return out
59	63	# fall through, let underlying cbor.dump decide if it can encode object

76	80	return obj
77	81	if isinstance(obj, dict):
78	82	# update in place
79		for k,v in obj.iteritems():
	83	if _IS_PY3:
	84	items = obj.items()
	85	else:
	86	items = obj.iteritems()
	87	for k,v in items:
80	88	# assume key is a primitive
81	89	obj[k] = self.decode(v)
82	90	return obj

-1

cbor.egg-info/PKG-INFO less more

0	0	Metadata-Version: 1.1
1	1	Name: cbor
2		Version: 0.1.21
	2	Version: 0.1.24
3	3	Summary: RFC 7049 - Concise Binary Object Representation
4	4	Home-page: https://bitbucket.org/bodhisnarkva/cbor
5	5	Author: Brian Olson

-0

cbor.egg-info/SOURCES.txt less more

0	0	setup.py
1	1	c/cbor.h
2	2	c/cbormodule.c
	3	cbor/VERSION.py
3	4	cbor/__init__.py
4	5	cbor/cbor.py
5	6	cbor/cbor_rpc_client.py

-1

setup.py less more

11	11	# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12	12	# See the License for the specific language governing permissions and
13	13	# limitations under the License.
	14
	15	# Thanks!
	16	# to Mic Bowman for a bunch of work and impetus on dumps(,sort_keys=)
14	17
15	18	from distutils.command.build_ext import build_ext
16	19	from distutils.errors import (CCompilerError, DistutilsExecError,

52	55	raise
53	56
54	57
	58	VERSION = eval(open('cbor/VERSION.py','rb').read())
	59
	60
55	61	setup_options = dict(
56	62	name='cbor',
57		version='0.1.21',
	63	version=VERSION,
58	64	description='RFC 7049 - Concise Binary Object Representation',
59	65	long_description="""
60	66	An implementation of RFC 7049 - Concise Binary Object Representation (CBOR).