1F#9y2!?MB-#oK|54iFTM$h_t-LL9`M)dcajeN}G`Wx8EZce$6|RS)aru@m
zb+dsH!0H+b{%>0XeB$sx)`okLy)phprHPN1F@+f?MQ*<5<|_@p5ari+$?*8Fm;<-X!gys2hX_E!-Kb0vqbmwQxMP3(Eu@Xt%xp1NBL@-T(jq
literal 0
HcmV?d00001
diff --git a/lib/rotary_embedding_torch/__pycache__/rotary_embedding_torch.cpython-39.pyc b/lib/rotary_embedding_torch/__pycache__/rotary_embedding_torch.cpython-39.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..37902f15d94fc6173a9f62b30d8a8ee38d8e4c6a
GIT binary patch
literal 7411
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
literal 0
HcmV?d00001
diff --git a/lib/rotary_embedding_torch/rotary_embedding_torch.py b/lib/rotary_embedding_torch/rotary_embedding_torch.py
new file mode 100644
index 0000000..8937875
--- /dev/null
+++ b/lib/rotary_embedding_torch/rotary_embedding_torch.py
@@ -0,0 +1,291 @@
+from __future__ import annotations
+from math import pi, log
+
+import torch
+from torch.nn import Module, ModuleList
+from torch.cuda.amp import autocast
+from torch import nn, einsum, broadcast_tensors, Tensor
+
+from einops import rearrange, repeat
+
+from typing import Literal
+
+# helper functions
+
+def exists(val):
+ return val is not None
+
+def default(val, d):
+ return val if exists(val) else d
+
+# broadcat, as tortoise-tts was using it
+
+def broadcat(tensors, dim = -1):
+ broadcasted_tensors = broadcast_tensors(*tensors)
+ return torch.cat(broadcasted_tensors, dim = dim)
+
+# rotary embedding helper functions
+
+def rotate_half(x):
+ x = rearrange(x, '... (d r) -> ... d r', r = 2)
+ x1, x2 = x.unbind(dim = -1)
+ x = torch.stack((-x2, x1), dim = -1)
+ return rearrange(x, '... d r -> ... (d r)')
+
+@autocast(enabled = False)
+def apply_rotary_emb(freqs, t, start_index = 0, scale = 1., seq_dim = -2):
+ dtype = t.dtype
+
+ if t.ndim == 3:
+ seq_len = t.shape[seq_dim]
+ freqs = freqs[-seq_len:]
+
+ rot_dim = freqs.shape[-1]
+ end_index = start_index + rot_dim
+
+ assert rot_dim <= t.shape[-1], f'feature dimension {t.shape[-1]} is not of sufficient size to rotate in all the positions {rot_dim}'
+
+ t_left, t, t_right = t[..., :start_index], t[..., start_index:end_index], t[..., end_index:]
+ t = (t * freqs.cos() * scale) + (rotate_half(t) * freqs.sin() * scale)
+ out = torch.cat((t_left, t, t_right), dim = -1)
+
+ return out.type(dtype)
+
+# learned rotation helpers
+
+def apply_learned_rotations(rotations, t, start_index = 0, freq_ranges = None):
+ if exists(freq_ranges):
+ rotations = einsum('..., f -> ... f', rotations, freq_ranges)
+ rotations = rearrange(rotations, '... r f -> ... (r f)')
+
+ rotations = repeat(rotations, '... n -> ... (n r)', r = 2)
+ return apply_rotary_emb(rotations, t, start_index = start_index)
+
+# classes
+
+class RotaryEmbedding(Module):
+ def __init__(
+ self,
+ dim,
+ custom_freqs: Tensor | None = None,
+ freqs_for: Literal['lang', 'pixel', 'constant'] = 'lang',
+ theta = 10000,
+ max_freq = 10,
+ num_freqs = 1,
+ learned_freq = False,
+ use_xpos = False,
+ xpos_scale_base = 512,
+ interpolate_factor = 1.,
+ theta_rescale_factor = 1.,
+ seq_before_head_dim = False,
+ cache_if_possible = True
+ ):
+ super().__init__()
+ # proposed by reddit user bloc97, to rescale rotary embeddings to longer sequence length without fine-tuning
+ # has some connection to NTK literature
+ # https://www.reddit.com/r/LocalLLaMA/comments/14lz7j5/ntkaware_scaled_rope_allows_llama_models_to_have/
+
+ theta *= theta_rescale_factor ** (dim / (dim - 2))
+
+ self.freqs_for = freqs_for
+
+ if exists(custom_freqs):
+ freqs = custom_freqs
+ elif freqs_for == 'lang':
+ freqs = 1. / (theta ** (torch.arange(0, dim, 2)[:(dim // 2)].float() / dim))
+ elif freqs_for == 'pixel':
+ freqs = torch.linspace(1., max_freq / 2, dim // 2) * pi
+ elif freqs_for == 'constant':
+ freqs = torch.ones(num_freqs).float()
+
+ self.cache_if_possible = cache_if_possible
+
+ self.tmp_store('cached_freqs', None)
+ self.tmp_store('cached_scales', None)
+
+ self.freqs = nn.Parameter(freqs, requires_grad = learned_freq)
+
+ self.learned_freq = learned_freq
+
+ # dummy for device
+
+ self.tmp_store('dummy', torch.tensor(0))
+
+ # default sequence dimension
+
+ self.seq_before_head_dim = seq_before_head_dim
+ self.default_seq_dim = -3 if seq_before_head_dim else -2
+
+ # interpolation factors
+
+ assert interpolate_factor >= 1.
+ self.interpolate_factor = interpolate_factor
+
+ # xpos
+
+ self.use_xpos = use_xpos
+ if not use_xpos:
+ self.tmp_store('scale', None)
+ return
+
+ scale = (torch.arange(0, dim, 2) + 0.4 * dim) / (1.4 * dim)
+ self.scale_base = xpos_scale_base
+ self.tmp_store('scale', scale)
+
+ # add apply_rotary_emb as static method
+
+ self.apply_rotary_emb = staticmethod(apply_rotary_emb)
+
+ @property
+ def device(self):
+ return self.dummy.device
+
+ def tmp_store(self, key, value):
+ self.register_buffer(key, value, persistent = False)
+
+ def get_seq_pos(self, seq_len, device, dtype, offset = 0):
+ return (torch.arange(seq_len, device = device, dtype = dtype) + offset) / self.interpolate_factor
+
+ def rotate_queries_or_keys(self, t, seq_dim = None, offset = 0, scale = None):
+ seq_dim = default(seq_dim, self.default_seq_dim)
+
+ assert not self.use_xpos or exists(scale), 'you must use `.rotate_queries_and_keys` method instead and pass in both queries and keys, for length extrapolatable rotary embeddings'
+
+ device, dtype, seq_len = t.device, t.dtype, t.shape[seq_dim]
+
+ seq = self.get_seq_pos(seq_len, device = device, dtype = dtype, offset = offset)
+
+ freqs = self.forward(seq, seq_len = seq_len, offset = offset)
+
+ if seq_dim == -3:
+ freqs = rearrange(freqs, 'n d -> n 1 d')
+
+ return apply_rotary_emb(freqs, t, scale = default(scale, 1.), seq_dim = seq_dim)
+
+ def rotate_queries_with_cached_keys(self, q, k, seq_dim = None, offset = 0):
+ dtype, device, seq_dim = q.dtype, q.device, default(seq_dim, self.default_seq_dim)
+
+ q_len, k_len = q.shape[seq_dim], k.shape[seq_dim]
+ assert q_len <= k_len
+
+ q_scale = k_scale = 1.
+
+ if self.use_xpos:
+ seq = self.get_seq_pos(k_len, dtype = dtype, device = device)
+
+ q_scale = self.get_scale(seq[-q_len:]).type(dtype)
+ k_scale = self.get_scale(seq).type(dtype)
+
+ rotated_q = self.rotate_queries_or_keys(q, seq_dim = seq_dim, scale = q_scale, offset = k_len - q_len + offset)
+ rotated_k = self.rotate_queries_or_keys(k, seq_dim = seq_dim, scale = k_scale ** -1)
+
+ rotated_q = rotated_q.type(q.dtype)
+ rotated_k = rotated_k.type(k.dtype)
+
+ return rotated_q, rotated_k
+
+ def rotate_queries_and_keys(self, q, k, seq_dim = None):
+ seq_dim = default(seq_dim, self.default_seq_dim)
+
+ assert self.use_xpos
+ device, dtype, seq_len = q.device, q.dtype, q.shape[seq_dim]
+
+ seq = self.get_seq_pos(seq_len, dtype = dtype, device = device)
+
+ freqs = self.forward(seq, seq_len = seq_len)
+ scale = self.get_scale(seq, seq_len = seq_len).to(dtype)
+
+ if seq_dim == -3:
+ freqs = rearrange(freqs, 'n d -> n 1 d')
+ scale = rearrange(scale, 'n d -> n 1 d')
+
+ rotated_q = apply_rotary_emb(freqs, q, scale = scale, seq_dim = seq_dim)
+ rotated_k = apply_rotary_emb(freqs, k, scale = scale ** -1, seq_dim = seq_dim)
+
+ rotated_q = rotated_q.type(q.dtype)
+ rotated_k = rotated_k.type(k.dtype)
+
+ return rotated_q, rotated_k
+
+ def get_scale(
+ self,
+ t: Tensor,
+ seq_len: int | None = None,
+ offset = 0
+ ):
+ assert self.use_xpos
+
+ should_cache = (
+ self.cache_if_possible and
+ exists(seq_len)
+ )
+
+ if (
+ should_cache and \
+ exists(self.cached_scales) and \
+ (seq_len + offset) <= self.cached_scales.shape[0]
+ ):
+ return self.cached_scales[offset:(offset + seq_len)]
+
+ scale = 1.
+ if self.use_xpos:
+ power = (t - len(t) // 2) / self.scale_base
+ scale = self.scale ** rearrange(power, 'n -> n 1')
+ scale = torch.cat((scale, scale), dim = -1)
+
+ if should_cache:
+ self.tmp_store('cached_scales', scale)
+
+ return scale
+
+ def get_axial_freqs(self, *dims):
+ Colon = slice(None)
+ all_freqs = []
+
+ for ind, dim in enumerate(dims):
+ if self.freqs_for == 'pixel':
+ pos = torch.linspace(-1, 1, steps = dim, device = self.device)
+ else:
+ pos = torch.arange(dim, device = self.device)
+
+ freqs = self.forward(pos, seq_len = dim)
+
+ all_axis = [None] * len(dims)
+ all_axis[ind] = Colon
+
+ new_axis_slice = (Ellipsis, *all_axis, Colon)
+ all_freqs.append(freqs[new_axis_slice])
+
+ all_freqs = broadcast_tensors(*all_freqs)
+ return torch.cat(all_freqs, dim = -1)
+
+ @autocast(enabled = False)
+ def forward(
+ self,
+ t: Tensor,
+ seq_len = None,
+ offset = 0
+ ):
+ should_cache = (
+ self.cache_if_possible and \
+ not self.learned_freq and \
+ exists(seq_len) and \
+ self.freqs_for != 'pixel'
+ )
+
+ if (
+ should_cache and \
+ exists(self.cached_freqs) and \
+ (offset + seq_len) <= self.cached_freqs.shape[0]
+ ):
+ return self.cached_freqs[offset:(offset + seq_len)].detach()
+
+ freqs = self.freqs
+
+ freqs = einsum('..., f -> ... f', t.type(freqs.dtype), freqs)
+ freqs = repeat(freqs, '... n -> ... (n r)', r = 2)
+
+ if should_cache:
+ self.tmp_store('cached_freqs', freqs.detach())
+
+ return freqs
diff --git a/lib/simplejson/__init__.py b/lib/simplejson/__init__.py
new file mode 100644
index 0000000..807b9da
--- /dev/null
+++ b/lib/simplejson/__init__.py
@@ -0,0 +1,562 @@
+r"""JSON (JavaScript Object Notation) is a subset of
+JavaScript syntax (ECMA-262 3rd edition) used as a lightweight data
+interchange format.
+
+:mod:`simplejson` exposes an API familiar to users of the standard library
+:mod:`marshal` and :mod:`pickle` modules. It is the externally maintained
+version of the :mod:`json` library contained in Python 2.6, but maintains
+compatibility back to Python 2.5 and (currently) has significant performance
+advantages, even without using the optional C extension for speedups.
+
+Encoding basic Python object hierarchies::
+
+ >>> import simplejson as json
+ >>> json.dumps(['foo', {'bar': ('baz', None, 1.0, 2)}])
+ '["foo", {"bar": ["baz", null, 1.0, 2]}]'
+ >>> print(json.dumps("\"foo\bar"))
+ "\"foo\bar"
+ >>> print(json.dumps(u'\u1234'))
+ "\u1234"
+ >>> print(json.dumps('\\'))
+ "\\"
+ >>> print(json.dumps({"c": 0, "b": 0, "a": 0}, sort_keys=True))
+ {"a": 0, "b": 0, "c": 0}
+ >>> from simplejson.compat import StringIO
+ >>> io = StringIO()
+ >>> json.dump(['streaming API'], io)
+ >>> io.getvalue()
+ '["streaming API"]'
+
+Compact encoding::
+
+ >>> import simplejson as json
+ >>> obj = [1,2,3,{'4': 5, '6': 7}]
+ >>> json.dumps(obj, separators=(',',':'), sort_keys=True)
+ '[1,2,3,{"4":5,"6":7}]'
+
+Pretty printing::
+
+ >>> import simplejson as json
+ >>> print(json.dumps({'4': 5, '6': 7}, sort_keys=True, indent=' '))
+ {
+ "4": 5,
+ "6": 7
+ }
+
+Decoding JSON::
+
+ >>> import simplejson as json
+ >>> obj = [u'foo', {u'bar': [u'baz', None, 1.0, 2]}]
+ >>> json.loads('["foo", {"bar":["baz", null, 1.0, 2]}]') == obj
+ True
+ >>> json.loads('"\\"foo\\bar"') == u'"foo\x08ar'
+ True
+ >>> from simplejson.compat import StringIO
+ >>> io = StringIO('["streaming API"]')
+ >>> json.load(io)[0] == 'streaming API'
+ True
+
+Specializing JSON object decoding::
+
+ >>> import simplejson as json
+ >>> def as_complex(dct):
+ ... if '__complex__' in dct:
+ ... return complex(dct['real'], dct['imag'])
+ ... return dct
+ ...
+ >>> json.loads('{"__complex__": true, "real": 1, "imag": 2}',
+ ... object_hook=as_complex)
+ (1+2j)
+ >>> from decimal import Decimal
+ >>> json.loads('1.1', parse_float=Decimal) == Decimal('1.1')
+ True
+
+Specializing JSON object encoding::
+
+ >>> import simplejson as json
+ >>> def encode_complex(obj):
+ ... if isinstance(obj, complex):
+ ... return [obj.real, obj.imag]
+ ... raise TypeError('Object of type %s is not JSON serializable' %
+ ... obj.__class__.__name__)
+ ...
+ >>> json.dumps(2 + 1j, default=encode_complex)
+ '[2.0, 1.0]'
+ >>> json.JSONEncoder(default=encode_complex).encode(2 + 1j)
+ '[2.0, 1.0]'
+ >>> ''.join(json.JSONEncoder(default=encode_complex).iterencode(2 + 1j))
+ '[2.0, 1.0]'
+
+Using simplejson.tool from the shell to validate and pretty-print::
+
+ $ echo '{"json":"obj"}' | python -m simplejson.tool
+ {
+ "json": "obj"
+ }
+ $ echo '{ 1.2:3.4}' | python -m simplejson.tool
+ Expecting property name: line 1 column 3 (char 2)
+
+Parsing multiple documents serialized as JSON lines (newline-delimited JSON)::
+
+ >>> import simplejson as json
+ >>> def loads_lines(docs):
+ ... for doc in docs.splitlines():
+ ... yield json.loads(doc)
+ ...
+ >>> sum(doc["count"] for doc in loads_lines('{"count":1}\n{"count":2}\n{"count":3}\n'))
+ 6
+
+Serializing multiple objects to JSON lines (newline-delimited JSON)::
+
+ >>> import simplejson as json
+ >>> def dumps_lines(objs):
+ ... for obj in objs:
+ ... yield json.dumps(obj, separators=(',',':')) + '\n'
+ ...
+ >>> ''.join(dumps_lines([{'count': 1}, {'count': 2}, {'count': 3}]))
+ '{"count":1}\n{"count":2}\n{"count":3}\n'
+
+"""
+from __future__ import absolute_import
+__version__ = '3.19.2'
+__all__ = [
+ 'dump', 'dumps', 'load', 'loads',
+ 'JSONDecoder', 'JSONDecodeError', 'JSONEncoder',
+ 'OrderedDict', 'simple_first', 'RawJSON'
+]
+
+__author__ = 'Bob Ippolito '
+
+from decimal import Decimal
+
+from .errors import JSONDecodeError
+from .raw_json import RawJSON
+from .decoder import JSONDecoder
+from .encoder import JSONEncoder, JSONEncoderForHTML
+def _import_OrderedDict():
+ import collections
+ try:
+ return collections.OrderedDict
+ except AttributeError:
+ from . import ordered_dict
+ return ordered_dict.OrderedDict
+OrderedDict = _import_OrderedDict()
+
+def _import_c_make_encoder():
+ try:
+ from ._speedups import make_encoder
+ return make_encoder
+ except ImportError:
+ return None
+
+_default_encoder = JSONEncoder()
+
+def dump(obj, fp, skipkeys=False, ensure_ascii=True, check_circular=True,
+ allow_nan=False, cls=None, indent=None, separators=None,
+ encoding='utf-8', default=None, use_decimal=True,
+ namedtuple_as_object=True, tuple_as_array=True,
+ bigint_as_string=False, sort_keys=False, item_sort_key=None,
+ for_json=False, ignore_nan=False, int_as_string_bitcount=None,
+ iterable_as_array=False, **kw):
+ """Serialize ``obj`` as a JSON formatted stream to ``fp`` (a
+ ``.write()``-supporting file-like object).
+
+ If *skipkeys* is true then ``dict`` keys that are not basic types
+ (``str``, ``int``, ``long``, ``float``, ``bool``, ``None``)
+ will be skipped instead of raising a ``TypeError``.
+
+ If *ensure_ascii* is false (default: ``True``), then the output may
+ contain non-ASCII characters, so long as they do not need to be escaped
+ by JSON. When it is true, all non-ASCII characters are escaped.
+
+ If *allow_nan* is true (default: ``False``), then out of range ``float``
+ values (``nan``, ``inf``, ``-inf``) will be serialized to
+ their JavaScript equivalents (``NaN``, ``Infinity``, ``-Infinity``)
+ instead of raising a ValueError. See
+ *ignore_nan* for ECMA-262 compliant behavior.
+
+ If *indent* is a string, then JSON array elements and object members
+ will be pretty-printed with a newline followed by that string repeated
+ for each level of nesting. ``None`` (the default) selects the most compact
+ representation without any newlines.
+
+ If specified, *separators* should be an
+ ``(item_separator, key_separator)`` tuple. The default is ``(', ', ': ')``
+ if *indent* is ``None`` and ``(',', ': ')`` otherwise. To get the most
+ compact JSON representation, you should specify ``(',', ':')`` to eliminate
+ whitespace.
+
+ *encoding* is the character encoding for str instances, default is UTF-8.
+
+ *default(obj)* is a function that should return a serializable version
+ of obj or raise ``TypeError``. The default simply raises ``TypeError``.
+
+ If *use_decimal* is true (default: ``True``) then decimal.Decimal
+ will be natively serialized to JSON with full precision.
+
+ If *namedtuple_as_object* is true (default: ``True``),
+ :class:`tuple` subclasses with ``_asdict()`` methods will be encoded
+ as JSON objects.
+
+ If *tuple_as_array* is true (default: ``True``),
+ :class:`tuple` (and subclasses) will be encoded as JSON arrays.
+
+ If *iterable_as_array* is true (default: ``False``),
+ any object not in the above table that implements ``__iter__()``
+ will be encoded as a JSON array.
+
+ If *bigint_as_string* is true (default: ``False``), ints 2**53 and higher
+ or lower than -2**53 will be encoded as strings. This is to avoid the
+ rounding that happens in Javascript otherwise. Note that this is still a
+ lossy operation that will not round-trip correctly and should be used
+ sparingly.
+
+ If *int_as_string_bitcount* is a positive number (n), then int of size
+ greater than or equal to 2**n or lower than or equal to -2**n will be
+ encoded as strings.
+
+ If specified, *item_sort_key* is a callable used to sort the items in
+ each dictionary. This is useful if you want to sort items other than
+ in alphabetical order by key. This option takes precedence over
+ *sort_keys*.
+
+ If *sort_keys* is true (default: ``False``), the output of dictionaries
+ will be sorted by item.
+
+ If *for_json* is true (default: ``False``), objects with a ``for_json()``
+ method will use the return value of that method for encoding as JSON
+ instead of the object.
+
+ If *ignore_nan* is true (default: ``False``), then out of range
+ :class:`float` values (``nan``, ``inf``, ``-inf``) will be serialized as
+ ``null`` in compliance with the ECMA-262 specification. If true, this will
+ override *allow_nan*.
+
+ To use a custom ``JSONEncoder`` subclass (e.g. one that overrides the
+ ``.default()`` method to serialize additional types), specify it with
+ the ``cls`` kwarg. NOTE: You should use *default* or *for_json* instead
+ of subclassing whenever possible.
+
+ """
+ # cached encoder
+ if (not skipkeys and ensure_ascii and
+ check_circular and not allow_nan and
+ cls is None and indent is None and separators is None and
+ encoding == 'utf-8' and default is None and use_decimal
+ and namedtuple_as_object and tuple_as_array and not iterable_as_array
+ and not bigint_as_string and not sort_keys
+ and not item_sort_key and not for_json
+ and not ignore_nan and int_as_string_bitcount is None
+ and not kw
+ ):
+ iterable = _default_encoder.iterencode(obj)
+ else:
+ if cls is None:
+ cls = JSONEncoder
+ iterable = cls(skipkeys=skipkeys, ensure_ascii=ensure_ascii,
+ check_circular=check_circular, allow_nan=allow_nan, indent=indent,
+ separators=separators, encoding=encoding,
+ default=default, use_decimal=use_decimal,
+ namedtuple_as_object=namedtuple_as_object,
+ tuple_as_array=tuple_as_array,
+ iterable_as_array=iterable_as_array,
+ bigint_as_string=bigint_as_string,
+ sort_keys=sort_keys,
+ item_sort_key=item_sort_key,
+ for_json=for_json,
+ ignore_nan=ignore_nan,
+ int_as_string_bitcount=int_as_string_bitcount,
+ **kw).iterencode(obj)
+ # could accelerate with writelines in some versions of Python, at
+ # a debuggability cost
+ for chunk in iterable:
+ fp.write(chunk)
+
+
+def dumps(obj, skipkeys=False, ensure_ascii=True, check_circular=True,
+ allow_nan=False, cls=None, indent=None, separators=None,
+ encoding='utf-8', default=None, use_decimal=True,
+ namedtuple_as_object=True, tuple_as_array=True,
+ bigint_as_string=False, sort_keys=False, item_sort_key=None,
+ for_json=False, ignore_nan=False, int_as_string_bitcount=None,
+ iterable_as_array=False, **kw):
+ """Serialize ``obj`` to a JSON formatted ``str``.
+
+ If ``skipkeys`` is true then ``dict`` keys that are not basic types
+ (``str``, ``int``, ``long``, ``float``, ``bool``, ``None``)
+ will be skipped instead of raising a ``TypeError``.
+
+ If *ensure_ascii* is false (default: ``True``), then the output may
+ contain non-ASCII characters, so long as they do not need to be escaped
+ by JSON. When it is true, all non-ASCII characters are escaped.
+
+ If ``check_circular`` is false, then the circular reference check
+ for container types will be skipped and a circular reference will
+ result in an ``OverflowError`` (or worse).
+
+ If *allow_nan* is true (default: ``False``), then out of range ``float``
+ values (``nan``, ``inf``, ``-inf``) will be serialized to
+ their JavaScript equivalents (``NaN``, ``Infinity``, ``-Infinity``)
+ instead of raising a ValueError. See
+ *ignore_nan* for ECMA-262 compliant behavior.
+
+ If ``indent`` is a string, then JSON array elements and object members
+ will be pretty-printed with a newline followed by that string repeated
+ for each level of nesting. ``None`` (the default) selects the most compact
+ representation without any newlines. For backwards compatibility with
+ versions of simplejson earlier than 2.1.0, an integer is also accepted
+ and is converted to a string with that many spaces.
+
+ If specified, ``separators`` should be an
+ ``(item_separator, key_separator)`` tuple. The default is ``(', ', ': ')``
+ if *indent* is ``None`` and ``(',', ': ')`` otherwise. To get the most
+ compact JSON representation, you should specify ``(',', ':')`` to eliminate
+ whitespace.
+
+ ``encoding`` is the character encoding for bytes instances, default is
+ UTF-8.
+
+ ``default(obj)`` is a function that should return a serializable version
+ of obj or raise TypeError. The default simply raises TypeError.
+
+ If *use_decimal* is true (default: ``True``) then decimal.Decimal
+ will be natively serialized to JSON with full precision.
+
+ If *namedtuple_as_object* is true (default: ``True``),
+ :class:`tuple` subclasses with ``_asdict()`` methods will be encoded
+ as JSON objects.
+
+ If *tuple_as_array* is true (default: ``True``),
+ :class:`tuple` (and subclasses) will be encoded as JSON arrays.
+
+ If *iterable_as_array* is true (default: ``False``),
+ any object not in the above table that implements ``__iter__()``
+ will be encoded as a JSON array.
+
+ If *bigint_as_string* is true (not the default), ints 2**53 and higher
+ or lower than -2**53 will be encoded as strings. This is to avoid the
+ rounding that happens in Javascript otherwise.
+
+ If *int_as_string_bitcount* is a positive number (n), then int of size
+ greater than or equal to 2**n or lower than or equal to -2**n will be
+ encoded as strings.
+
+ If specified, *item_sort_key* is a callable used to sort the items in
+ each dictionary. This is useful if you want to sort items other than
+ in alphabetical order by key. This option takes precedence over
+ *sort_keys*.
+
+ If *sort_keys* is true (default: ``False``), the output of dictionaries
+ will be sorted by item.
+
+ If *for_json* is true (default: ``False``), objects with a ``for_json()``
+ method will use the return value of that method for encoding as JSON
+ instead of the object.
+
+ If *ignore_nan* is true (default: ``False``), then out of range
+ :class:`float` values (``nan``, ``inf``, ``-inf``) will be serialized as
+ ``null`` in compliance with the ECMA-262 specification. If true, this will
+ override *allow_nan*.
+
+ To use a custom ``JSONEncoder`` subclass (e.g. one that overrides the
+ ``.default()`` method to serialize additional types), specify it with
+ the ``cls`` kwarg. NOTE: You should use *default* instead of subclassing
+ whenever possible.
+
+ """
+ # cached encoder
+ if (not skipkeys and ensure_ascii and
+ check_circular and not allow_nan and
+ cls is None and indent is None and separators is None and
+ encoding == 'utf-8' and default is None and use_decimal
+ and namedtuple_as_object and tuple_as_array and not iterable_as_array
+ and not bigint_as_string and not sort_keys
+ and not item_sort_key and not for_json
+ and not ignore_nan and int_as_string_bitcount is None
+ and not kw
+ ):
+ return _default_encoder.encode(obj)
+ if cls is None:
+ cls = JSONEncoder
+ return cls(
+ skipkeys=skipkeys, ensure_ascii=ensure_ascii,
+ check_circular=check_circular, allow_nan=allow_nan, indent=indent,
+ separators=separators, encoding=encoding, default=default,
+ use_decimal=use_decimal,
+ namedtuple_as_object=namedtuple_as_object,
+ tuple_as_array=tuple_as_array,
+ iterable_as_array=iterable_as_array,
+ bigint_as_string=bigint_as_string,
+ sort_keys=sort_keys,
+ item_sort_key=item_sort_key,
+ for_json=for_json,
+ ignore_nan=ignore_nan,
+ int_as_string_bitcount=int_as_string_bitcount,
+ **kw).encode(obj)
+
+
+_default_decoder = JSONDecoder()
+
+
+def load(fp, encoding=None, cls=None, object_hook=None, parse_float=None,
+ parse_int=None, parse_constant=None, object_pairs_hook=None,
+ use_decimal=False, allow_nan=False, **kw):
+ """Deserialize ``fp`` (a ``.read()``-supporting file-like object containing
+ a JSON document as `str` or `bytes`) to a Python object.
+
+ *encoding* determines the encoding used to interpret any
+ `bytes` objects decoded by this instance (``'utf-8'`` by
+ default). It has no effect when decoding `str` objects.
+
+ *object_hook*, if specified, will be called with the result of every
+ JSON object decoded and its return value will be used in place of the
+ given :class:`dict`. This can be used to provide custom
+ deserializations (e.g. to support JSON-RPC class hinting).
+
+ *object_pairs_hook* is an optional function that will be called with
+ the result of any object literal decode with an ordered list of pairs.
+ The return value of *object_pairs_hook* will be used instead of the
+ :class:`dict`. This feature can be used to implement custom decoders
+ that rely on the order that the key and value pairs are decoded (for
+ example, :func:`collections.OrderedDict` will remember the order of
+ insertion). If *object_hook* is also defined, the *object_pairs_hook*
+ takes priority.
+
+ *parse_float*, if specified, will be called with the string of every
+ JSON float to be decoded. By default, this is equivalent to
+ ``float(num_str)``. This can be used to use another datatype or parser
+ for JSON floats (e.g. :class:`decimal.Decimal`).
+
+ *parse_int*, if specified, will be called with the string of every
+ JSON int to be decoded. By default, this is equivalent to
+ ``int(num_str)``. This can be used to use another datatype or parser
+ for JSON integers (e.g. :class:`float`).
+
+ *allow_nan*, if True (default false), will allow the parser to
+ accept the non-standard floats ``NaN``, ``Infinity``, and ``-Infinity``
+ and enable the use of the deprecated *parse_constant*.
+
+ If *use_decimal* is true (default: ``False``) then it implies
+ parse_float=decimal.Decimal for parity with ``dump``.
+
+ *parse_constant*, if specified, will be
+ called with one of the following strings: ``'-Infinity'``,
+ ``'Infinity'``, ``'NaN'``. It is not recommended to use this feature,
+ as it is rare to parse non-compliant JSON containing these values.
+
+ To use a custom ``JSONDecoder`` subclass, specify it with the ``cls``
+ kwarg. NOTE: You should use *object_hook* or *object_pairs_hook* instead
+ of subclassing whenever possible.
+
+ """
+ return loads(fp.read(),
+ encoding=encoding, cls=cls, object_hook=object_hook,
+ parse_float=parse_float, parse_int=parse_int,
+ parse_constant=parse_constant, object_pairs_hook=object_pairs_hook,
+ use_decimal=use_decimal, allow_nan=allow_nan, **kw)
+
+
+def loads(s, encoding=None, cls=None, object_hook=None, parse_float=None,
+ parse_int=None, parse_constant=None, object_pairs_hook=None,
+ use_decimal=False, allow_nan=False, **kw):
+ """Deserialize ``s`` (a ``str`` or ``unicode`` instance containing a JSON
+ document) to a Python object.
+
+ *encoding* determines the encoding used to interpret any
+ :class:`bytes` objects decoded by this instance (``'utf-8'`` by
+ default). It has no effect when decoding :class:`unicode` objects.
+
+ *object_hook*, if specified, will be called with the result of every
+ JSON object decoded and its return value will be used in place of the
+ given :class:`dict`. This can be used to provide custom
+ deserializations (e.g. to support JSON-RPC class hinting).
+
+ *object_pairs_hook* is an optional function that will be called with
+ the result of any object literal decode with an ordered list of pairs.
+ The return value of *object_pairs_hook* will be used instead of the
+ :class:`dict`. This feature can be used to implement custom decoders
+ that rely on the order that the key and value pairs are decoded (for
+ example, :func:`collections.OrderedDict` will remember the order of
+ insertion). If *object_hook* is also defined, the *object_pairs_hook*
+ takes priority.
+
+ *parse_float*, if specified, will be called with the string of every
+ JSON float to be decoded. By default, this is equivalent to
+ ``float(num_str)``. This can be used to use another datatype or parser
+ for JSON floats (e.g. :class:`decimal.Decimal`).
+
+ *parse_int*, if specified, will be called with the string of every
+ JSON int to be decoded. By default, this is equivalent to
+ ``int(num_str)``. This can be used to use another datatype or parser
+ for JSON integers (e.g. :class:`float`).
+
+ *allow_nan*, if True (default false), will allow the parser to
+ accept the non-standard floats ``NaN``, ``Infinity``, and ``-Infinity``
+ and enable the use of the deprecated *parse_constant*.
+
+ If *use_decimal* is true (default: ``False``) then it implies
+ parse_float=decimal.Decimal for parity with ``dump``.
+
+ *parse_constant*, if specified, will be
+ called with one of the following strings: ``'-Infinity'``,
+ ``'Infinity'``, ``'NaN'``. It is not recommended to use this feature,
+ as it is rare to parse non-compliant JSON containing these values.
+
+ To use a custom ``JSONDecoder`` subclass, specify it with the ``cls``
+ kwarg. NOTE: You should use *object_hook* or *object_pairs_hook* instead
+ of subclassing whenever possible.
+
+ """
+ if (cls is None and encoding is None and object_hook is None and
+ parse_int is None and parse_float is None and
+ parse_constant is None and object_pairs_hook is None
+ and not use_decimal and not allow_nan and not kw):
+ return _default_decoder.decode(s)
+ if cls is None:
+ cls = JSONDecoder
+ if object_hook is not None:
+ kw['object_hook'] = object_hook
+ if object_pairs_hook is not None:
+ kw['object_pairs_hook'] = object_pairs_hook
+ if parse_float is not None:
+ kw['parse_float'] = parse_float
+ if parse_int is not None:
+ kw['parse_int'] = parse_int
+ if parse_constant is not None:
+ kw['parse_constant'] = parse_constant
+ if use_decimal:
+ if parse_float is not None:
+ raise TypeError("use_decimal=True implies parse_float=Decimal")
+ kw['parse_float'] = Decimal
+ if allow_nan:
+ kw['allow_nan'] = True
+ return cls(encoding=encoding, **kw).decode(s)
+
+
+def _toggle_speedups(enabled):
+ from . import decoder as dec
+ from . import encoder as enc
+ from . import scanner as scan
+ c_make_encoder = _import_c_make_encoder()
+ if enabled:
+ dec.scanstring = dec.c_scanstring or dec.py_scanstring
+ enc.c_make_encoder = c_make_encoder
+ enc.encode_basestring_ascii = (enc.c_encode_basestring_ascii or
+ enc.py_encode_basestring_ascii)
+ scan.make_scanner = scan.c_make_scanner or scan.py_make_scanner
+ else:
+ dec.scanstring = dec.py_scanstring
+ enc.c_make_encoder = None
+ enc.encode_basestring_ascii = enc.py_encode_basestring_ascii
+ scan.make_scanner = scan.py_make_scanner
+ dec.make_scanner = scan.make_scanner
+ global _default_decoder
+ _default_decoder = JSONDecoder()
+ global _default_encoder
+ _default_encoder = JSONEncoder()
+
+def simple_first(kv):
+ """Helper function to pass to item_sort_key to sort simple
+ elements to the top, then container elements.
+ """
+ return (isinstance(kv[1], (list, dict, tuple)), kv[0])
diff --git a/lib/simplejson/_speedups.cp39-win_amd64.pyd b/lib/simplejson/_speedups.cp39-win_amd64.pyd
new file mode 100644
index 0000000000000000000000000000000000000000..f6e8451da56388ea519cb7f6dad3bac866cc9816
GIT binary patch
literal 39936
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