# -*- coding: utf-8 -*- import collections import inspect import json import sys __version__ = '1.4' SUPPORTED_FUNCS = ['loads', 'load', 'dumps', 'dump'] json_module = collections.namedtuple('json_module', ' '.join(SUPPORTED_FUNCS)) try: import ujson # https://github.com/esnme/ultrajson except ImportError: ujson = False try: import rapidjson # https://github.com/python-rapidjson/python-rapidjson except ImportError: rapidjson = False try: import simplejson # https://github.com/simplejson/simplejson simplejson_slow = False if not simplejson.encoder.c_make_encoder: simplejson, simplejson_slow = simplejson_slow, simplejson except ImportError: simplejson = simplejson_slow = False try: import nssjson # https://github.com/lelit/nssjson nssjson_slow = False if not nssjson.encoder.c_make_encoder: nssjson, nssjson_slow = nssjson_slow, nssjson except ImportError: nssjson = nssjson_slow = False try: import yajl # https://github.com/rtyler/py-yajl except ImportError: yajl = False try: import cjson # https://github.com/AGProjects/python-cjson cjson = json_module( dump=None, dumps=cjson.encode, load=None, loads=cjson.decode) except ImportError: cjson = None try: import metamagic.json as mjson # https://github.com/sprymix/metamagic.json except ImportError: mjson = False try: import orjson # https://github.com/ijl/orjson except ImportError: orjson = False try: pypy = sys.pypy_version_info is not None except AttributeError: pypy = False try: assert basestring is not None except NameError: basestring = str if pypy: # NOTE(mattgiles): in benchmarks, using pypy, the standard library's json # module outperforms all third party libraries. DEFAULT_RANKINGS = { 'dump': [], 'dumps': [], 'load': [], 'loads': []} elif sys.version_info.major == 3: DEFAULT_RANKINGS = { 'dump': [rapidjson, ujson, yajl, json, nssjson, simplejson, nssjson_slow, simplejson_slow], 'dumps': [orjson, mjson, rapidjson, ujson, yajl, json, nssjson, simplejson, nssjson_slow, simplejson_slow], 'load': [ujson, simplejson, rapidjson, json, nssjson, yajl, nssjson_slow, simplejson_slow], 'loads': [orjson, ujson, simplejson, rapidjson, json, nssjson, yajl, nssjson_slow, simplejson_slow]} else: DEFAULT_RANKINGS = { 'dump': [ujson, yajl, json, nssjson, simplejson, nssjson_slow, simplejson_slow], 'dumps': [ujson, yajl, json, cjson, nssjson, simplejson, nssjson_slow, simplejson_slow], 'load': [ujson, simplejson, nssjson, yajl, json, simplejson_slow, nssjson_slow], 'loads': [cjson, ujson, simplejson, nssjson, yajl, json, simplejson_slow, nssjson_slow]} def _get_kwarg_names(func): try: # NOTE(mattgiles): there are compatibility issues between Python2 and # Python3 when using `inspect.getargspec`. Here we elect to try # Python27-compliant code first, falling back to Python36. This order # is important because of the behavior of intermediate Python versions. return inspect.getargspec(func)[0] except (AttributeError, TypeError, ValueError): return inspect.getfullargspec(func).kwonlyargs def _best_available_json_func(func_name, ranking, **kwargs): _available = [] for module in ranking: if isinstance(module, basestring): if module not in globals(): try: globals()[module] = __import__(module) except ModuleNotFoundError: globals()[module] = False if globals()[module]: _available.append(globals()[module]) else: if module: _available.append(module) if not kwargs: return getattr(_available[0], func_name) for module in _available: try: func = getattr(module, func_name) if set(kwargs.keys()).issubset(_get_kwarg_names(func)): return func except (AttributeError, TypeError, ValueError): continue raise TypeError('mujson {}() got an unexpected kwarg'.format(func_name)) def mujson_function(name, alias_for=None, ranking=None): """Return the "best" available version of some JSON function. The true performance ranking of different JSON libraries varies widely based on the actual JSON data being encoded or decoded. Therefore, it may be desirable to pass your own `ranking` based on your knowledge of the common shape or characteristics of the JSON data relevant to your project. Args: name (str): the global name of your mujson function. Must have the same string value as the variable to which you assign the output of `mujson_function()`. mujson will infer the underlying json function from the name if that function is in the name. alias_for (str): the json function for which your mujson function is an alias. Must be one of ["load", "loads", "dump", "dumps"]. ranking (list): if a list, will use ranking when evaluating the best module available. If not passed, the default rankings will be used. NOTE(mattgiles): the returned function behaves differently the first time it is invoked, compared to subsequent times. On first invocation, before any output is returned, the "best" implementation of the desired json function that is available for import is retrieved and made to replace the temporary function returned by `mujson_function` in the global namespace. The reason for this hackery is because, given the implicit desire for speed, extra function calls are are needlessly slow. """ if alias_for is None: for func in SUPPORTED_FUNCS: if name.find(func) >= 0: alias_for = func break if alias_for is None: raise ValueError( 'mujson_function requires that either `name` contains a substring ' 'in {} or that `alias_for` is specified.'.format(SUPPORTED_FUNCS)) if alias_for not in SUPPORTED_FUNCS: raise ValueError( '`alias_for` must be one of: {}'.format(SUPPORTED_FUNCS)) if ranking is None: ranking = DEFAULT_RANKINGS[alias_for] if 'json' not in ranking: ranking.append('json') def temp_json_func(*args, **kwargs): func = _best_available_json_func(alias_for, ranking, **kwargs) globals()[name] = func return func(*args, **kwargs) return temp_json_func dump = mujson_function('dump') dumps = mujson_function('dumps') load = mujson_function('load') loads = mujson_function('loads') # NOTE(mattgiles): programmers can elect to explicitly import `compliant_*` # versions of the standard functions to avoid run time errors that depend on # what concrete uses of e.g. `mujson.dumps` hit `mujson_function:temp_json_func` # first. Although `mujson_function` guarantees that the first time it is called # it protects against choosing a JSON library which does not support invoked # kwargs, this dynamic behavior can lead to NON-DETERMINISTIC behavior in # larger or more complex libraries where mujson is used multiple places with # varying signatures. NON_COMPLIANT = [ujson, cjson, mjson, orjson] compliant_dump = mujson_function( 'compliant_dump', ranking=[m for m in DEFAULT_RANKINGS['dump'] if m not in NON_COMPLIANT]) compliant_dumps = mujson_function( 'compliant_dumps', ranking=[m for m in DEFAULT_RANKINGS['dumps'] if m not in NON_COMPLIANT]) compliant_load = mujson_function( 'compliant_load', ranking=[m for m in DEFAULT_RANKINGS['load'] if m not in NON_COMPLIANT]) compliant_loads = mujson_function( 'compliant_loads', ranking=[m for m in DEFAULT_RANKINGS['loads'] if m not in NON_COMPLIANT])