My favorites | Sign in
Project Home
Repository:
Checkout   Browse   Changes   Clones  
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
# -*- coding: utf-8 -*-
#
# Copyright (C) 2009 Christopher Lenz
# All rights reserved.
#
# This software is licensed as described in the file COPYING, which
# you should have received as part of this distribution.

"""Thin abstraction layer over the different available modules for decoding
and encoding JSON data.

This module currently supports the following JSON modules:
- ``simplejson``: http://code.google.com/p/simplejson/
- ``cjson``: http://pypi.python.org/pypi/python-cjson
- ``json``: This is the version of ``simplejson`` that is bundled with the
Python standard library since version 2.6
(see http://docs.python.org/library/json.html)

The default behavior is to use ``simplejson`` if installed, and otherwise
fallback to the standard library module. To explicitly tell CouchDB-Python
which module to use, invoke the `use()` function with the module name::

from couchdb import json
json.use('cjson')

In addition to choosing one of the above modules, you can also configure
CouchDB-Python to use custom decoding and encoding functions::

from couchdb import json
json.use(decode=my_decode, encode=my_encode)

"""

__all__ = ['decode', 'encode', 'use']

import warnings
import os

_initialized = False
_using = os.environ.get('COUCHDB_PYTHON_JSON')
_decode = None
_encode = None


def decode(string):
"""Decode the given JSON string.

:param string: the JSON string to decode
:type string: basestring
:return: the corresponding Python data structure
:rtype: object
"""
if not _initialized:
_initialize()
return _decode(string)


def encode(obj):
"""Encode the given object as a JSON string.

:param obj: the Python data structure to encode
:type obj: object
:return: the corresponding JSON string
:rtype: basestring
"""
if not _initialized:
_initialize()
return _encode(obj)


def use(module=None, decode=None, encode=None):
"""Set the JSON library that should be used, either by specifying a known
module name, or by providing a decode and encode function.

The modules "simplejson" and "json" are currently supported for the
``module`` parameter.

If provided, the ``decode`` parameter must be a callable that accepts a
JSON string and returns a corresponding Python data structure. The
``encode`` callable must accept a Python data structure and return the
corresponding JSON string. Exceptions raised by decoding and encoding
should be propagated up unaltered.

:param module: the name of the JSON library module to use, or the module
object itself
:type module: str or module
:param decode: a function for decoding JSON strings
:type decode: callable
:param encode: a function for encoding objects as JSON strings
:type encode: callable
"""
global _decode, _encode, _initialized, _using
if module is not None:
if not isinstance(module, basestring):
module = module.__name__
if module not in ('cjson', 'json', 'simplejson'):
raise ValueError('Unsupported JSON module %s' % module)
_using = module
_initialized = False
else:
assert decode is not None and encode is not None
_using = 'custom'
_decode = decode
_encode = encode
_initialized = True


def _initialize():
global _initialized

def _init_simplejson():
global _decode, _encode
import simplejson
_decode = lambda string, loads=simplejson.loads: loads(string)
_encode = lambda obj, dumps=simplejson.dumps: \
dumps(obj, allow_nan=False, ensure_ascii=False)

def _init_cjson():
global _decode, _encode
import cjson
_decode = lambda string, decode=cjson.decode: decode(string)
_encode = lambda obj, encode=cjson.encode: encode(obj)

def _init_stdlib():
global _decode, _encode
json = __import__('json', {}, {})
_decode = lambda string, loads=json.loads: loads(string)
_encode = lambda obj, dumps=json.dumps: \
dumps(obj, allow_nan=False, ensure_ascii=False)

if _using == 'simplejson':
_init_simplejson()
elif _using == 'cjson':
warnings.warn("Builtin cjson support is deprecated. Please use the "
"default or provide custom decode/encode functions "
"[2011-11-09].",
DeprecationWarning, stacklevel=1)
_init_cjson()
elif _using == 'json':
_init_stdlib()
elif _using != 'custom':
try:
_init_simplejson()
except ImportError:
_init_stdlib()
_initialized = True

Change log

7db07fb6811f by Matt Goodall <matt.goodall> on Nov 16, 2011   Diff
Deprecate built-in cjson support.
Go to: 
Project members, sign in to write a code review

Older revisions

7a6416912f2f by Matt Goodall <matt.goodall> on Oct 11, 2011   Diff
Get default JSON implementation from
OS environ, mostly to aid testing.
f392a741227c by Dirkjan Ochtman <dirk...@ochtman.nl> on Dec 8, 2009   Diff
Fix up permissions and shebangs for
scripts vs. modules (fixes #98).
9a5348134319 by Christopher Lenz <cml...@gmx.de> on Jul 24, 2009   Diff
Port r191 to 0.6.x maintenance branch.
All revisions of this file

File info

Size: 4738 bytes, 146 lines
Powered by Google Project Hosting